@fuel-ts/account 0.0.0-rc-2152-20240429145747 → 0.0.0-rc-2037-20240430003658

package/dist/test-utils.global.js

@@ -173,13 +173,13 @@
           if (str !== lowered && str !== uppered)
             return "Mixed-case string " + str;
           str = lowered;
-          const split2 = str.lastIndexOf("1");
-          if (split2 === -1)
+          const split3 = str.lastIndexOf("1");
+          if (split3 === -1)
             return "No separator character for " + str;
-          if (split2 === 0)
+          if (split3 === 0)
             return "Missing prefix for " + str;
-          const prefix = str.slice(0, split2);
-          const wordChars = str.slice(split2 + 1);
+          const prefix = str.slice(0, split3);
+          const wordChars = str.slice(split3 + 1);
           if (wordChars.length < 6)
             return "Data too short";
           let chk = prefixChk(prefix);
@@ -1080,7 +1080,7 @@
           }
           return this;
         };
-        BN2.prototype.add = function add(num) {
+        BN2.prototype.add = function add2(num) {
           var res;
           if (num.negative !== 0 && this.negative === 0) {
             num.negative = 0;
@@ -2794,7 +2794,7 @@
           }
           return r;
         };
-        MPrime.prototype.split = function split2(input, out) {
+        MPrime.prototype.split = function split3(input, out) {
           input.iushrn(this.n, 0, out);
         };
         MPrime.prototype.imulK = function imulK(num) {
@@ -2808,7 +2808,7 @@
           );
         }
         inherits(K256, MPrime);
-        K256.prototype.split = function split2(input, output3) {
+        K256.prototype.split = function split3(input, output3) {
           var mask2 = 4194303;
           var outLen = Math.min(input.length, 9);
           for (var i = 0; i < outLen; i++) {
@@ -2944,7 +2944,7 @@
           }
           return this.m.sub(a)._forceRed(this);
         };
-        Red.prototype.add = function add(a, b) {
+        Red.prototype.add = function add2(a, b) {
           this._verify2(a, b);
           var res = a.add(b);
           if (res.cmp(this.m) >= 0) {
@@ -20408,7 +20408,7 @@ spurious results.`);
         }
         return instance.ptr;
       }
-      function add(dst, lhs, rhs) {
+      function add2(dst, lhs, rhs) {
         const ret3 = wasm$1.add(dst, lhs, rhs);
         return Instruction.__wrap(ret3);
       }
@@ -27987,7 +27987,7 @@ spurious results.`);
       exports.WQOP = WQOP;
       exports.XOR = XOR;
       exports.XORI = XORI;
-      exports.add = add;
+      exports.add = add2;
       exports.addi = addi2;
       exports.aloc = aloc;
       exports.and = and;
@@ -30264,13 +30264,13 @@ spurious results.`);
           createDebug.names = [];
           createDebug.skips = [];
           var i;
-          var split2 = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
-          var len = split2.length;
+          var split3 = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+          var len = split3.length;
           for (i = 0; i < len; i++) {
-            if (!split2[i]) {
+            if (!split3[i]) {
               continue;
             }
-            namespaces = split2[i].replace(/\*/g, ".*?");
+            namespaces = split3[i].replace(/\*/g, ".*?");
             if (namespaces[0] === "-") {
               createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
             } else {
@@ -31198,9 +31198,9 @@ spurious results.`);
   function setBigUint64(view, byteOffset, value, isLE3) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE3);
-    const _32n2 = BigInt(32);
+    const _32n3 = BigInt(32);
     const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
+    const wh = Number(value >> _32n3 & _u32_max);
     const wl = Number(value & _u32_max);
     const h = isLE3 ? 4 : 0;
     const l = isLE3 ? 0 : 4;
@@ -32930,6 +32930,14 @@ This unreleased fuel-core build may include features and updates not yet support
         amount: 12704439083013452e3,
         data: "",
         da_height: 0
+      },
+      {
+        sender: "0x22cae5308938e8b4caf217b6464884f6331eff05e81468df8ccd08126effc8d0",
+        recipient: "0x8d2af98a4198732a46bf65d87a73427dd7608acaad2414585d8ccdd6f59c437b",
+        nonce: "0x381de90750098776c71544527fd253412908dec3d07ce9a7367bd1ba975908a0",
+        amount: 18446744073709552e3,
+        data: "",
+        da_height: 0
       }
     ],
     contracts: [],
@@ -32947,7 +32955,7 @@ This unreleased fuel-core build may include features and updates not yet support
   }
 
   // ../crypto/dist/index.mjs
-  var import_crypto7 = __toESM(__require("crypto"), 1);
+  var import_crypto8 = __toESM(__require("crypto"), 1);
 
   // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/_version.js
   var version = "6.7.1";
@@ -33114,6 +33122,18 @@ This unreleased fuel-core build may include features and updates not yet support
   function getBytes(value, name) {
     return _getBytes(value, name, false);
   }
+  function isHexString(value, length) {
+    if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+      return false;
+    }
+    if (typeof length === "number" && value.length !== 2 + 2 * length) {
+      return false;
+    }
+    if (length === true && value.length % 2 !== 0) {
+      return false;
+    }
+    return true;
+  }
   var HexCharacters2 = "0123456789abcdef";
   function hexlify2(data) {
     const bytes3 = getBytes(data);
@@ -33474,7 +33494,74 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var assert_default = assert2;
 
+  // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/_u64.js
+  var U32_MASK642 = BigInt(2 ** 32 - 1);
+  var _32n2 = BigInt(32);
+  function fromBig2(n, le = false) {
+    if (le)
+      return { h: Number(n & U32_MASK642), l: Number(n >> _32n2 & U32_MASK642) };
+    return { h: Number(n >> _32n2 & U32_MASK642) | 0, l: Number(n & U32_MASK642) | 0 };
+  }
+  function split2(lst, le = false) {
+    let Ah = new Uint32Array(lst.length);
+    let Al = new Uint32Array(lst.length);
+    for (let i = 0; i < lst.length; i++) {
+      const { h, l } = fromBig2(lst[i], le);
+      [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+  }
+  var toBig = (h, l) => BigInt(h >>> 0) << _32n2 | BigInt(l >>> 0);
+  var shrSH = (h, l, s) => h >>> s;
+  var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+  var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+  var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+  var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+  var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+  var rotr32H = (h, l) => l;
+  var rotr32L = (h, l) => h;
+  var rotlSH2 = (h, l, s) => h << s | l >>> 32 - s;
+  var rotlSL2 = (h, l, s) => l << s | h >>> 32 - s;
+  var rotlBH2 = (h, l, s) => l << s - 32 | h >>> 64 - s;
+  var rotlBL2 = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+  }
+  var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+  var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+  var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+  var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+  var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+  var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+  var u64 = {
+    fromBig: fromBig2,
+    split: split2,
+    toBig,
+    shrSH,
+    shrSL,
+    rotrSH,
+    rotrSL,
+    rotrBH,
+    rotrBL,
+    rotr32H,
+    rotr32L,
+    rotlSH: rotlSH2,
+    rotlSL: rotlSL2,
+    rotlBH: rotlBH2,
+    rotlBL: rotlBL2,
+    add,
+    add3L,
+    add3H,
+    add4L,
+    add4H,
+    add5H,
+    add5L
+  };
+  var u64_default = u64;
+
   // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/utils.js
+  var u322 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
   var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
   var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
   if (!isLE2)
@@ -33507,14 +33594,224 @@ This unreleased fuel-core build may include features and updates not yet support
     hashC.create = () => hashConstructor();
     return hashC;
   }
+  function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
+
+  // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/sha3.js
+  var [SHA3_PI2, SHA3_ROTL2, _SHA3_IOTA2] = [[], [], []];
+  var _0n2 = BigInt(0);
+  var _1n2 = BigInt(1);
+  var _2n2 = BigInt(2);
+  var _7n2 = BigInt(7);
+  var _256n2 = BigInt(256);
+  var _0x71n2 = BigInt(113);
+  for (let round = 0, R = _1n2, x = 1, y = 0; round < 24; round++) {
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI2.push(2 * (5 * y + x));
+    SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n2;
+    for (let j = 0; j < 7; j++) {
+      R = (R << _1n2 ^ (R >> _7n2) * _0x71n2) % _256n2;
+      if (R & _2n2)
+        t ^= _1n2 << (_1n2 << BigInt(j)) - _1n2;
+    }
+    _SHA3_IOTA2.push(t);
+  }
+  var [SHA3_IOTA_H2, SHA3_IOTA_L2] = u64_default.split(_SHA3_IOTA2, true);
+  var rotlH2 = (h, l, s) => s > 32 ? u64_default.rotlBH(h, l, s) : u64_default.rotlSH(h, l, s);
+  var rotlL2 = (h, l, s) => s > 32 ? u64_default.rotlBL(h, l, s) : u64_default.rotlSL(h, l, s);
+  function keccakP2(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    for (let round = 24 - rounds; round < 24; round++) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+      for (let x = 0; x < 10; x += 2) {
+        const idx1 = (x + 8) % 10;
+        const idx0 = (x + 2) % 10;
+        const B0 = B[idx0];
+        const B1 = B[idx0 + 1];
+        const Th = rotlH2(B0, B1, 1) ^ B[idx1];
+        const Tl = rotlL2(B0, B1, 1) ^ B[idx1 + 1];
+        for (let y = 0; y < 50; y += 10) {
+          s[x + y] ^= Th;
+          s[x + y + 1] ^= Tl;
+        }
+      }
+      let curH = s[2];
+      let curL = s[3];
+      for (let t = 0; t < 24; t++) {
+        const shift = SHA3_ROTL2[t];
+        const Th = rotlH2(curH, curL, shift);
+        const Tl = rotlL2(curH, curL, shift);
+        const PI = SHA3_PI2[t];
+        curH = s[PI];
+        curL = s[PI + 1];
+        s[PI] = Th;
+        s[PI + 1] = Tl;
+      }
+      for (let y = 0; y < 50; y += 10) {
+        for (let x = 0; x < 10; x++)
+          B[x] = s[y + x];
+        for (let x = 0; x < 10; x++)
+          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+      }
+      s[0] ^= SHA3_IOTA_H2[round];
+      s[1] ^= SHA3_IOTA_L2[round];
+    }
+    B.fill(0);
+  }
+  var Keccak2 = class extends Hash2 {
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+      super();
+      this.blockLen = blockLen;
+      this.suffix = suffix;
+      this.outputLen = outputLen;
+      this.enableXOF = enableXOF;
+      this.rounds = rounds;
+      this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
+      this.destroyed = false;
+      assert_default.number(outputLen);
+      if (0 >= this.blockLen || this.blockLen >= 200)
+        throw new Error("Sha3 supports only keccak-f1600 function");
+      this.state = new Uint8Array(200);
+      this.state32 = u322(this.state);
+    }
+    keccak() {
+      keccakP2(this.state32, this.rounds);
+      this.posOut = 0;
+      this.pos = 0;
+    }
+    update(data) {
+      assert_default.exists(this);
+      const { blockLen, state } = this;
+      data = toBytes2(data);
+      const len = data.length;
+      for (let pos = 0; pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        for (let i = 0; i < take; i++)
+          state[this.pos++] ^= data[pos++];
+        if (this.pos === blockLen)
+          this.keccak();
+      }
+      return this;
+    }
+    finish() {
+      if (this.finished)
+        return;
+      this.finished = true;
+      const { state, suffix, pos, blockLen } = this;
+      state[pos] ^= suffix;
+      if ((suffix & 128) !== 0 && pos === blockLen - 1)
+        this.keccak();
+      state[blockLen - 1] ^= 128;
+      this.keccak();
+    }
+    writeInto(out) {
+      assert_default.exists(this, false);
+      assert_default.bytes(out);
+      this.finish();
+      const bufferOut = this.state;
+      const { blockLen } = this;
+      for (let pos = 0, len = out.length; pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.keccak();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes3) {
+      assert_default.number(bytes3);
+      return this.xofInto(new Uint8Array(bytes3));
+    }
+    digestInto(out) {
+      assert_default.output(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+      this.destroyed = true;
+      this.state.fill(0);
+    }
+    _cloneInto(to) {
+      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+      to || (to = new Keccak2(blockLen, suffix, outputLen, enableXOF, rounds));
+      to.state32.set(this.state32);
+      to.pos = this.pos;
+      to.posOut = this.posOut;
+      to.finished = this.finished;
+      to.rounds = rounds;
+      to.suffix = suffix;
+      to.outputLen = outputLen;
+      to.enableXOF = enableXOF;
+      to.destroyed = this.destroyed;
+      return to;
+    }
+  };
+  var gen2 = (suffix, blockLen, outputLen) => wrapConstructor2(() => new Keccak2(blockLen, suffix, outputLen));
+  var sha3_2242 = gen2(6, 144, 224 / 8);
+  var sha3_2562 = gen2(6, 136, 256 / 8);
+  var sha3_3842 = gen2(6, 104, 384 / 8);
+  var sha3_5122 = gen2(6, 72, 512 / 8);
+  var keccak_2242 = gen2(1, 144, 224 / 8);
+  var keccak_2562 = gen2(1, 136, 256 / 8);
+  var keccak_3842 = gen2(1, 104, 384 / 8);
+  var keccak_5122 = gen2(1, 72, 512 / 8);
+  var genShake2 = (suffix, blockLen, outputLen) => wrapConstructorWithOpts((opts = {}) => new Keccak2(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+  var shake1282 = genShake2(31, 168, 128 / 8);
+  var shake2562 = genShake2(31, 136, 256 / 8);
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/keccak.js
+  var locked2 = false;
+  var _keccak256 = function(data) {
+    return keccak_2562(data);
+  };
+  var __keccak256 = _keccak256;
+  function keccak256(_data) {
+    const data = getBytes(_data, "data");
+    return hexlify2(__keccak256(data));
+  }
+  keccak256._ = _keccak256;
+  keccak256.lock = function() {
+    locked2 = true;
+  };
+  keccak256.register = function(func) {
+    if (locked2) {
+      throw new TypeError("keccak256 is locked");
+    }
+    __keccak256 = func;
+  };
+  Object.freeze(keccak256);
 
   // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/_sha2.js
   function setBigUint642(view, byteOffset, value, isLE3) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE3);
-    const _32n2 = BigInt(32);
+    const _32n3 = BigInt(32);
     const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
+    const wh = Number(value >> _32n3 & _u32_max);
     const wl = Number(value & _u32_max);
     const h = isLE3 ? 4 : 0;
     const l = isLE3 ? 0 : 4;
@@ -33686,7 +33983,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var ripemd160 = wrapConstructor2(() => new RIPEMD160());
 
   // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/ripemd160.js
-  var locked2 = false;
+  var locked3 = false;
   var _ripemd160 = function(data) {
     return ripemd160(data);
   };
@@ -33697,10 +33994,10 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   ripemd1602._ = _ripemd160;
   ripemd1602.lock = function() {
-    locked2 = true;
+    locked3 = true;
   };
   ripemd1602.register = function(func) {
-    if (locked2) {
+    if (locked3) {
       throw new TypeError("ripemd160 is locked");
     }
     __ripemd160 = func;
@@ -33708,7 +34005,7 @@ This unreleased fuel-core build may include features and updates not yet support
   Object.freeze(ripemd1602);
 
   // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/pbkdf2.js
-  var locked3 = false;
+  var locked4 = false;
   var _pbkdf2 = function(password, salt, iterations, keylen, algo) {
     return (0, import_crypto2.pbkdf2Sync)(password, salt, iterations, keylen, algo);
   };
@@ -33720,19 +34017,602 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   pbkdf22._ = _pbkdf2;
   pbkdf22.lock = function() {
-    locked3 = true;
+    locked4 = true;
   };
   pbkdf22.register = function(func) {
-    if (locked3) {
+    if (locked4) {
       throw new Error("pbkdf2 is locked");
     }
     __pbkdf2 = func;
   };
   Object.freeze(pbkdf22);
 
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/address/address.js
+  var BN_03 = BigInt(0);
+  var BN_36 = BigInt(36);
+  function getChecksumAddress(address) {
+    address = address.toLowerCase();
+    const chars = address.substring(2).split("");
+    const expanded = new Uint8Array(40);
+    for (let i = 0; i < 40; i++) {
+      expanded[i] = chars[i].charCodeAt(0);
+    }
+    const hashed = getBytes(keccak256(expanded));
+    for (let i = 0; i < 40; i += 2) {
+      if (hashed[i >> 1] >> 4 >= 8) {
+        chars[i] = chars[i].toUpperCase();
+      }
+      if ((hashed[i >> 1] & 15) >= 8) {
+        chars[i + 1] = chars[i + 1].toUpperCase();
+      }
+    }
+    return "0x" + chars.join("");
+  }
+  var ibanLookup = {};
+  for (let i = 0; i < 10; i++) {
+    ibanLookup[String(i)] = String(i);
+  }
+  for (let i = 0; i < 26; i++) {
+    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
+  }
+  var safeDigits = 15;
+  function ibanChecksum(address) {
+    address = address.toUpperCase();
+    address = address.substring(4) + address.substring(0, 2) + "00";
+    let expanded = address.split("").map((c) => {
+      return ibanLookup[c];
+    }).join("");
+    while (expanded.length >= safeDigits) {
+      let block2 = expanded.substring(0, safeDigits);
+      expanded = parseInt(block2, 10) % 97 + expanded.substring(block2.length);
+    }
+    let checksum = String(98 - parseInt(expanded, 10) % 97);
+    while (checksum.length < 2) {
+      checksum = "0" + checksum;
+    }
+    return checksum;
+  }
+  var Base36 = function() {
+    ;
+    const result = {};
+    for (let i = 0; i < 36; i++) {
+      const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
+      result[key] = BigInt(i);
+    }
+    return result;
+  }();
+  function fromBase36(value) {
+    value = value.toLowerCase();
+    let result = BN_03;
+    for (let i = 0; i < value.length; i++) {
+      result = result * BN_36 + Base36[value[i]];
+    }
+    return result;
+  }
+  function getAddress(address) {
+    assertArgument(typeof address === "string", "invalid address", "address", address);
+    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
+      if (!address.startsWith("0x")) {
+        address = "0x" + address;
+      }
+      const result = getChecksumAddress(address);
+      assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
+      return result;
+    }
+    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
+      assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
+      let result = fromBase36(address.substring(4)).toString(16);
+      while (result.length < 40) {
+        result = "0" + result;
+      }
+      return getChecksumAddress("0x" + result);
+    }
+    assertArgument(false, "invalid address", "address", address);
+  }
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/transaction/accesslist.js
+  function accessSetify(addr, storageKeys) {
+    return {
+      address: getAddress(addr),
+      storageKeys: storageKeys.map((storageKey, index) => {
+        assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${index}]`, storageKey);
+        return storageKey.toLowerCase();
+      })
+    };
+  }
+  function accessListify(value) {
+    if (Array.isArray(value)) {
+      return value.map((set, index) => {
+        if (Array.isArray(set)) {
+          assertArgument(set.length === 2, "invalid slot set", `value[${index}]`, set);
+          return accessSetify(set[0], set[1]);
+        }
+        assertArgument(set != null && typeof set === "object", "invalid address-slot set", "value", value);
+        return accessSetify(set.address, set.storageKeys);
+      });
+    }
+    assertArgument(value != null && typeof value === "object", "invalid access list", "value", value);
+    const result = Object.keys(value).map((addr) => {
+      const storageKeys = value[addr].reduce((accum, storageKey) => {
+        accum[storageKey] = true;
+        return accum;
+      }, {});
+      return accessSetify(addr, Object.keys(storageKeys).sort());
+    });
+    result.sort((a, b) => a.address.localeCompare(b.address));
+    return result;
+  }
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/providers/plugins-network.js
+  var EnsAddress = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+  var NetworkPlugin = class {
+    /**
+     *  The name of the plugin.
+     *
+     *  It is recommended to use reverse-domain-notation, which permits
+     *  unique names with a known authority as well as hierarchal entries.
+     */
+    name;
+    /**
+     *  Creates a new **NetworkPlugin**.
+     */
+    constructor(name) {
+      defineProperties(this, { name });
+    }
+    /**
+     *  Creates a copy of this plugin.
+     */
+    clone() {
+      return new NetworkPlugin(this.name);
+    }
+  };
+  var GasCostPlugin = class extends NetworkPlugin {
+    /**
+     *  The block number to treat these values as valid from.
+     *
+     *  This allows a hardfork to have updated values included as well as
+     *  mulutiple hardforks to be supported.
+     */
+    effectiveBlock;
+    /**
+     *  The transactions base fee.
+     */
+    txBase;
+    /**
+     *  The fee for creating a new account.
+     */
+    txCreate;
+    /**
+     *  The fee per zero-byte in the data.
+     */
+    txDataZero;
+    /**
+     *  The fee per non-zero-byte in the data.
+     */
+    txDataNonzero;
+    /**
+     *  The fee per storage key in the [[link-eip-2930]] access list.
+     */
+    txAccessListStorageKey;
+    /**
+     *  The fee per address in the [[link-eip-2930]] access list.
+     */
+    txAccessListAddress;
+    /**
+     *  Creates a new GasCostPlugin from %%effectiveBlock%% until the
+     *  latest block or another GasCostPlugin supercedes that block number,
+     *  with the associated %%costs%%.
+     */
+    constructor(effectiveBlock, costs) {
+      if (effectiveBlock == null) {
+        effectiveBlock = 0;
+      }
+      super(`org.ethers.network.plugins.GasCost#${effectiveBlock || 0}`);
+      const props = { effectiveBlock };
+      function set(name, nullish) {
+        let value = (costs || {})[name];
+        if (value == null) {
+          value = nullish;
+        }
+        assertArgument(typeof value === "number", `invalud value for ${name}`, "costs", costs);
+        props[name] = value;
+      }
+      set("txBase", 21e3);
+      set("txCreate", 32e3);
+      set("txDataZero", 4);
+      set("txDataNonzero", 16);
+      set("txAccessListStorageKey", 1900);
+      set("txAccessListAddress", 2400);
+      defineProperties(this, props);
+    }
+    clone() {
+      return new GasCostPlugin(this.effectiveBlock, this);
+    }
+  };
+  var EnsPlugin = class extends NetworkPlugin {
+    /**
+     *  The ENS Registrty Contract address.
+     */
+    address;
+    /**
+     *  The chain ID that the ENS contract lives on.
+     */
+    targetNetwork;
+    /**
+     *  Creates a new **EnsPlugin** connected to %%address%% on the
+     *  %%targetNetwork%%. The default ENS address and mainnet is used
+     *  if unspecified.
+     */
+    constructor(address, targetNetwork) {
+      super("org.ethers.plugins.network.Ens");
+      defineProperties(this, {
+        address: address || EnsAddress,
+        targetNetwork: targetNetwork == null ? 1 : targetNetwork
+      });
+    }
+    clone() {
+      return new EnsPlugin(this.address, this.targetNetwork);
+    }
+  };
+  var FetchUrlFeeDataNetworkPlugin = class extends NetworkPlugin {
+    #url;
+    #processFunc;
+    /**
+     *  The URL to initialize the FetchRequest with in %%processFunc%%.
+     */
+    get url() {
+      return this.#url;
+    }
+    /**
+     *  The callback to use when computing the FeeData.
+     */
+    get processFunc() {
+      return this.#processFunc;
+    }
+    /**
+     *  Creates a new **FetchUrlFeeDataNetworkPlugin** which will
+     *  be used when computing the fee data for the network.
+     */
+    constructor(url, processFunc) {
+      super("org.ethers.plugins.network.FetchUrlFeeDataPlugin");
+      this.#url = url;
+      this.#processFunc = processFunc;
+    }
+    // We are immutable, so we can serve as our own clone
+    clone() {
+      return this;
+    }
+  };
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/providers/network.js
+  var Networks = /* @__PURE__ */ new Map();
+  var Network = class {
+    #name;
+    #chainId;
+    #plugins;
+    /**
+     *  Creates a new **Network** for %%name%% and %%chainId%%.
+     */
+    constructor(name, chainId) {
+      this.#name = name;
+      this.#chainId = getBigInt(chainId);
+      this.#plugins = /* @__PURE__ */ new Map();
+    }
+    /**
+     *  Returns a JSON-compatible representation of a Network.
+     */
+    toJSON() {
+      return { name: this.name, chainId: String(this.chainId) };
+    }
+    /**
+     *  The network common name.
+     *
+     *  This is the canonical name, as networks migh have multiple
+     *  names.
+     */
+    get name() {
+      return this.#name;
+    }
+    set name(value) {
+      this.#name = value;
+    }
+    /**
+     *  The network chain ID.
+     */
+    get chainId() {
+      return this.#chainId;
+    }
+    set chainId(value) {
+      this.#chainId = getBigInt(value, "chainId");
+    }
+    /**
+     *  Returns true if %%other%% matches this network. Any chain ID
+     *  must match, and if no chain ID is present, the name must match.
+     *
+     *  This method does not currently check for additional properties,
+     *  such as ENS address or plug-in compatibility.
+     */
+    matches(other) {
+      if (other == null) {
+        return false;
+      }
+      if (typeof other === "string") {
+        try {
+          return this.chainId === getBigInt(other);
+        } catch (error) {
+        }
+        return this.name === other;
+      }
+      if (typeof other === "number" || typeof other === "bigint") {
+        try {
+          return this.chainId === getBigInt(other);
+        } catch (error) {
+        }
+        return false;
+      }
+      if (typeof other === "object") {
+        if (other.chainId != null) {
+          try {
+            return this.chainId === getBigInt(other.chainId);
+          } catch (error) {
+          }
+          return false;
+        }
+        if (other.name != null) {
+          return this.name === other.name;
+        }
+        return false;
+      }
+      return false;
+    }
+    /**
+     *  Returns the list of plugins currently attached to this Network.
+     */
+    get plugins() {
+      return Array.from(this.#plugins.values());
+    }
+    /**
+     *  Attach a new %%plugin%% to this Network. The network name
+     *  must be unique, excluding any fragment.
+     */
+    attachPlugin(plugin) {
+      if (this.#plugins.get(plugin.name)) {
+        throw new Error(`cannot replace existing plugin: ${plugin.name} `);
+      }
+      this.#plugins.set(plugin.name, plugin.clone());
+      return this;
+    }
+    /**
+     *  Return the plugin, if any, matching %%name%% exactly. Plugins
+     *  with fragments will not be returned unless %%name%% includes
+     *  a fragment.
+     */
+    getPlugin(name) {
+      return this.#plugins.get(name) || null;
+    }
+    /**
+     *  Gets a list of all plugins that match %%name%%, with otr without
+     *  a fragment.
+     */
+    getPlugins(basename) {
+      return this.plugins.filter((p) => p.name.split("#")[0] === basename);
+    }
+    /**
+     *  Create a copy of this Network.
+     */
+    clone() {
+      const clone4 = new Network(this.name, this.chainId);
+      this.plugins.forEach((plugin) => {
+        clone4.attachPlugin(plugin.clone());
+      });
+      return clone4;
+    }
+    /**
+     *  Compute the intrinsic gas required for a transaction.
+     *
+     *  A GasCostPlugin can be attached to override the default
+     *  values.
+     */
+    computeIntrinsicGas(tx) {
+      const costs = this.getPlugin("org.ethers.plugins.network.GasCost") || new GasCostPlugin();
+      let gas = costs.txBase;
+      if (tx.to == null) {
+        gas += costs.txCreate;
+      }
+      if (tx.data) {
+        for (let i = 2; i < tx.data.length; i += 2) {
+          if (tx.data.substring(i, i + 2) === "00") {
+            gas += costs.txDataZero;
+          } else {
+            gas += costs.txDataNonzero;
+          }
+        }
+      }
+      if (tx.accessList) {
+        const accessList = accessListify(tx.accessList);
+        for (const addr in accessList) {
+          gas += costs.txAccessListAddress + costs.txAccessListStorageKey * accessList[addr].storageKeys.length;
+        }
+      }
+      return gas;
+    }
+    /**
+     *  Returns a new Network for the %%network%% name or chainId.
+     */
+    static from(network) {
+      injectCommonNetworks();
+      if (network == null) {
+        return Network.from("mainnet");
+      }
+      if (typeof network === "number") {
+        network = BigInt(network);
+      }
+      if (typeof network === "string" || typeof network === "bigint") {
+        const networkFunc = Networks.get(network);
+        if (networkFunc) {
+          return networkFunc();
+        }
+        if (typeof network === "bigint") {
+          return new Network("unknown", network);
+        }
+        assertArgument(false, "unknown network", "network", network);
+      }
+      if (typeof network.clone === "function") {
+        const clone4 = network.clone();
+        return clone4;
+      }
+      if (typeof network === "object") {
+        assertArgument(typeof network.name === "string" && typeof network.chainId === "number", "invalid network object name or chainId", "network", network);
+        const custom = new Network(network.name, network.chainId);
+        if (network.ensAddress || network.ensNetwork != null) {
+          custom.attachPlugin(new EnsPlugin(network.ensAddress, network.ensNetwork));
+        }
+        return custom;
+      }
+      assertArgument(false, "invalid network", "network", network);
+    }
+    /**
+     *  Register %%nameOrChainId%% with a function which returns
+     *  an instance of a Network representing that chain.
+     */
+    static register(nameOrChainId, networkFunc) {
+      if (typeof nameOrChainId === "number") {
+        nameOrChainId = BigInt(nameOrChainId);
+      }
+      const existing = Networks.get(nameOrChainId);
+      if (existing) {
+        assertArgument(false, `conflicting network for ${JSON.stringify(existing.name)}`, "nameOrChainId", nameOrChainId);
+      }
+      Networks.set(nameOrChainId, networkFunc);
+    }
+  };
+  function parseUnits(_value, decimals) {
+    const value = String(_value);
+    if (!value.match(/^[0-9.]+$/)) {
+      throw new Error(`invalid gwei value: ${_value}`);
+    }
+    const comps = value.split(".");
+    if (comps.length === 1) {
+      comps.push("");
+    }
+    if (comps.length !== 2) {
+      throw new Error(`invalid gwei value: ${_value}`);
+    }
+    while (comps[1].length < decimals) {
+      comps[1] += "0";
+    }
+    if (comps[1].length > 9) {
+      let frac = BigInt(comps[1].substring(0, 9));
+      if (!comps[1].substring(9).match(/^0+$/)) {
+        frac++;
+      }
+      comps[1] = frac.toString();
+    }
+    return BigInt(comps[0] + comps[1]);
+  }
+  function getGasStationPlugin(url) {
+    return new FetchUrlFeeDataNetworkPlugin(url, async (fetchFeeData, provider, request) => {
+      request.setHeader("User-Agent", "ethers");
+      let response;
+      try {
+        const [_response, _feeData] = await Promise.all([
+          request.send(),
+          fetchFeeData()
+        ]);
+        response = _response;
+        const payload = response.bodyJson.standard;
+        const feeData = {
+          gasPrice: _feeData.gasPrice,
+          maxFeePerGas: parseUnits(payload.maxFee, 9),
+          maxPriorityFeePerGas: parseUnits(payload.maxPriorityFee, 9)
+        };
+        return feeData;
+      } catch (error) {
+        assert(false, `error encountered with polygon gas station (${JSON.stringify(request.url)})`, "SERVER_ERROR", { request, response, error });
+      }
+    });
+  }
+  function getPriorityFeePlugin(maxPriorityFeePerGas) {
+    return new FetchUrlFeeDataNetworkPlugin("data:", async (fetchFeeData, provider, request) => {
+      const feeData = await fetchFeeData();
+      if (feeData.maxFeePerGas == null || feeData.maxPriorityFeePerGas == null) {
+        return feeData;
+      }
+      const baseFee = feeData.maxFeePerGas - feeData.maxPriorityFeePerGas;
+      return {
+        gasPrice: feeData.gasPrice,
+        maxFeePerGas: baseFee + maxPriorityFeePerGas,
+        maxPriorityFeePerGas
+      };
+    });
+  }
+  var injected = false;
+  function injectCommonNetworks() {
+    if (injected) {
+      return;
+    }
+    injected = true;
+    function registerEth(name, chainId, options) {
+      const func = function() {
+        const network = new Network(name, chainId);
+        if (options.ensNetwork != null) {
+          network.attachPlugin(new EnsPlugin(null, options.ensNetwork));
+        }
+        network.attachPlugin(new GasCostPlugin());
+        (options.plugins || []).forEach((plugin) => {
+          network.attachPlugin(plugin);
+        });
+        return network;
+      };
+      Network.register(name, func);
+      Network.register(chainId, func);
+      if (options.altNames) {
+        options.altNames.forEach((name2) => {
+          Network.register(name2, func);
+        });
+      }
+    }
+    registerEth("mainnet", 1, { ensNetwork: 1, altNames: ["homestead"] });
+    registerEth("ropsten", 3, { ensNetwork: 3 });
+    registerEth("rinkeby", 4, { ensNetwork: 4 });
+    registerEth("goerli", 5, { ensNetwork: 5 });
+    registerEth("kovan", 42, { ensNetwork: 42 });
+    registerEth("sepolia", 11155111, {});
+    registerEth("classic", 61, {});
+    registerEth("classicKotti", 6, {});
+    registerEth("arbitrum", 42161, {
+      ensNetwork: 1
+    });
+    registerEth("arbitrum-goerli", 421613, {});
+    registerEth("bnb", 56, { ensNetwork: 1 });
+    registerEth("bnbt", 97, {});
+    registerEth("linea", 59144, { ensNetwork: 1 });
+    registerEth("linea-goerli", 59140, {});
+    registerEth("matic", 137, {
+      ensNetwork: 1,
+      plugins: [
+        getGasStationPlugin("https://gasstation.polygon.technology/v2")
+      ]
+    });
+    registerEth("matic-mumbai", 80001, {
+      altNames: ["maticMumbai", "maticmum"],
+      plugins: [
+        getGasStationPlugin("https://gasstation-testnet.polygon.technology/v2")
+      ]
+    });
+    registerEth("optimism", 10, {
+      ensNetwork: 1,
+      plugins: [
+        getPriorityFeePlugin(BigInt("1000000"))
+      ]
+    });
+    registerEth("optimism-goerli", 420, {});
+    registerEth("xdai", 100, { ensNetwork: 1 });
+  }
+
   // ../crypto/dist/index.mjs
-  var import_crypto8 = __toESM(__require("crypto"), 1);
   var import_crypto9 = __toESM(__require("crypto"), 1);
+  var import_crypto10 = __toESM(__require("crypto"), 1);
   var scrypt3 = (params) => {
     const { password, salt, n, p, r, dklen } = params;
     const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
@@ -33741,7 +34621,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var keccak2562 = (data) => keccak_256(data);
   var bufferFromString = (string, encoding = "base64") => Uint8Array.from(Buffer.from(string, encoding));
   var randomBytes4 = (length) => {
-    const randomValues = Uint8Array.from(import_crypto8.default.randomBytes(length));
+    const randomValues = Uint8Array.from(import_crypto9.default.randomBytes(length));
     return randomValues;
   };
   var stringFromBuffer = (buffer, encoding = "base64") => Buffer.from(buffer).toString(encoding);
@@ -33756,7 +34636,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const salt = randomBytes4(32);
     const secret = keyFromPassword(password, salt);
     const dataBuffer = Uint8Array.from(Buffer.from(JSON.stringify(data), "utf-8"));
-    const cipher = await import_crypto7.default.createCipheriv(ALGORITHM, secret, iv);
+    const cipher = await import_crypto8.default.createCipheriv(ALGORITHM, secret, iv);
     let cipherData = cipher.update(dataBuffer);
     cipherData = Buffer.concat([cipherData, cipher.final()]);
     return {
@@ -33770,7 +34650,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const salt = bufferFromString(keystore.salt);
     const secret = keyFromPassword(password, salt);
     const encryptedText = bufferFromString(keystore.data);
-    const decipher = await import_crypto7.default.createDecipheriv(ALGORITHM, secret, iv);
+    const decipher = await import_crypto8.default.createDecipheriv(ALGORITHM, secret, iv);
     const decrypted = decipher.update(encryptedText);
     const deBuff = Buffer.concat([decrypted, decipher.final()]);
     const decryptedData = Buffer.from(deBuff).toString("utf-8");
@@ -33781,12 +34661,12 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   async function encryptJsonWalletData(data, key, iv) {
-    const cipher = await import_crypto9.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const cipher = await import_crypto10.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
     return new Uint8Array(encrypted);
   }
   async function decryptJsonWalletData(data, key, iv) {
-    const decipher = import_crypto9.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const decipher = import_crypto10.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const decrypted = await Buffer.concat([decipher.update(data), decipher.final()]);
     return new Uint8Array(decrypted);
   }
@@ -37404,9 +38284,9 @@ This unreleased fuel-core build may include features and updates not yet support
     utf8ToBytes: () => utf8ToBytes3,
     validateObject: () => validateObject
   });
-  var _0n2 = BigInt(0);
-  var _1n2 = BigInt(1);
-  var _2n2 = BigInt(2);
+  var _0n3 = BigInt(0);
+  var _1n3 = BigInt(1);
+  var _2n3 = BigInt(2);
   function isBytes3(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
@@ -37525,17 +38405,17 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   function bitLen(n) {
     let len;
-    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
+    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
       ;
     return len;
   }
   function bitGet(n, pos) {
-    return n >> BigInt(pos) & _1n2;
+    return n >> BigInt(pos) & _1n3;
   }
   var bitSet = (n, pos, value) => {
-    return n | (value ? _1n2 : _0n2) << BigInt(pos);
+    return n | (value ? _1n3 : _0n3) << BigInt(pos);
   };
-  var bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
+  var bitMask = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
   var u8n = (data) => new Uint8Array(data);
   var u8fr = (arr) => Uint8Array.from(arr);
   function createHmacDrbg(hashLen, qByteLen, hmacFn) {
@@ -37562,7 +38442,7 @@ This unreleased fuel-core build may include features and updates not yet support
       k = h(u8fr([1]), seed);
       v = h();
     };
-    const gen2 = () => {
+    const gen3 = () => {
       if (i++ >= 1e3)
         throw new Error("drbg: tried 1000 values");
       let len = 0;
@@ -37579,7 +38459,7 @@ This unreleased fuel-core build may include features and updates not yet support
       reset();
       reseed(seed);
       let res = void 0;
-      while (!(res = pred(gen2())))
+      while (!(res = pred(gen3())))
         reseed();
       reset();
       return res;
@@ -41553,6 +42433,13 @@ ${MessageCoinFragmentFragmentDoc}`;
   )
 }
     `;
+  var GetMessageByNonceDocument = lib_default2`
+    query getMessageByNonce($nonce: Nonce!) {
+  message(nonce: $nonce) {
+    ...messageFragment
+  }
+}
+    ${MessageFragmentFragmentDoc}`;
   var SubmitAndAwaitDocument = lib_default2`
     subscription submitAndAwait($encodedTransaction: HexString!) {
   submitAndAwait(tx: $encodedTransaction) {
@@ -41647,6 +42534,9 @@ ${MessageCoinFragmentFragmentDoc}`;
       produceBlocks(variables, options) {
         return requester(ProduceBlocksDocument, variables, options);
       },
+      getMessageByNonce(variables, options) {
+        return requester(GetMessageByNonceDocument, variables, options);
+      },
       submitAndAwait(variables, options) {
         return requester(SubmitAndAwaitDocument, variables, options);
       },
@@ -42388,6 +43278,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     name = "NoWitnessAtIndexError";
   };
 
+  // src/providers/transaction-request/helpers.ts
+  var isRequestInputCoin = (input) => input.type === InputType.Coin;
+  var isRequestInputMessage = (input) => input.type === InputType.Message;
+  var isRequestInputResource = (input) => isRequestInputCoin(input) || isRequestInputMessage(input);
+
   // src/providers/transaction-request/witness.ts
   var witnessify = (value) => {
     const data = arrayify(value);
@@ -42626,7 +43521,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param coin - Coin resource.
      */
     addCoinInput(coin) {
-      const { assetId, owner, amount } = coin;
+      const { assetId, owner, amount, id, predicate } = coin;
       let witnessIndex;
       if (coin.predicate) {
         witnessIndex = 0;
@@ -42637,13 +43532,14 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       }
       const input = {
-        ...coin,
+        id,
         type: InputType.Coin,
         owner: owner.toB256(),
         amount,
         assetId,
         txPointer: "0x00000000000000000000000000000000",
-        witnessIndex
+        witnessIndex,
+        predicate
       };
       this.pushInput(input);
       this.addChangeOutput(owner, assetId);
@@ -42655,7 +43551,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param message - Message resource.
      */
     addMessageInput(message) {
-      const { recipient, sender, amount, assetId } = message;
+      const { recipient, sender, amount, predicate, nonce, assetId } = message;
       let witnessIndex;
       if (message.predicate) {
         witnessIndex = 0;
@@ -42666,12 +43562,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       }
       const input = {
-        ...message,
+        nonce,
         type: InputType.Message,
         sender: sender.toB256(),
         recipient: recipient.toB256(),
         amount,
-        witnessIndex
+        witnessIndex,
+        predicate
       };
       this.pushInput(input);
       this.addChangeOutput(recipient, assetId);
@@ -42855,6 +43752,17 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     toJSON() {
       return normalizeJSON(this);
     }
+    removeWitness(index) {
+      this.witnesses.splice(index, 1);
+      this.adjustWitnessIndexes(index);
+    }
+    adjustWitnessIndexes(removedIndex) {
+      this.inputs.filter(isRequestInputResource).forEach((input) => {
+        if (input.witnessIndex > removedIndex) {
+          input.witnessIndex -= 1;
+        }
+      });
+    }
     updatePredicateGasUsed(inputs) {
       this.inputs.forEach((i) => {
         let correspondingInput;
@@ -43996,7 +44904,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   }
 
   // src/providers/transaction-response/transaction-response.ts
-  var TransactionResponse = class {
+  var TransactionResponse2 = class {
     /** Transaction ID */
     id;
     /** Current provider */
@@ -44026,7 +44934,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param provider - The provider.
      */
     static async create(id, provider, abis) {
-      const response = new TransactionResponse(id, provider, abis);
+      const response = new TransactionResponse2(id, provider, abis);
       await response.fetch();
       return response;
     }
@@ -44420,6 +45328,21 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       } = await this.operations.getVersion();
       return nodeVersion;
     }
+    /**
+     * @hidden
+     *
+     * Returns the network configuration of the connected Fuel node.
+     *
+     * @returns A promise that resolves to the network configuration object
+     */
+    async getNetwork() {
+      const {
+        name,
+        consensusParameters: { chainId }
+      } = await this.getChain();
+      const network = new Network(name, chainId.toNumber());
+      return Promise.resolve(network);
+    }
     /**
      * Returns the block number.
      *
@@ -44513,14 +45436,14 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           }
         }
         const transactionId2 = transactionRequest.getTransactionId(this.getChainId());
-        const response = new TransactionResponse(transactionId2, this, abis);
+        const response = new TransactionResponse2(transactionId2, this, abis);
         await response.fetch();
         return response;
       }
       const {
         submit: { id: transactionId }
       } = await this.operations.submit({ encodedTransaction });
-      return new TransactionResponse(transactionId, this, abis);
+      return new TransactionResponse2(transactionId, this, abis);
     }
     /**
      * Executes a transaction without actually submitting it to the chain.
@@ -45268,7 +46191,20 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     }
     // eslint-disable-next-line @typescript-eslint/require-await
     async getTransactionResponse(transactionId) {
-      return new TransactionResponse(transactionId, this);
+      return new TransactionResponse2(transactionId, this);
+    }
+    /**
+     * Returns Message for given nonce.
+     *
+     * @param nonce - The nonce of the message to retrieve.
+     * @returns A promise that resolves to the Message object.
+     */
+    async getMessageByNonce(nonce) {
+      const { message } = await this.operations.getMessageByNonce({ nonce });
+      if (!message) {
+        return null;
+      }
+      return message;
     }
   };
   var Provider = _Provider;
@@ -45782,9 +46718,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/modular.js
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  var _2n3 = BigInt(2);
+  var _0n4 = BigInt(0);
+  var _1n4 = BigInt(1);
+  var _2n4 = BigInt(2);
   var _3n = BigInt(3);
   var _4n = BigInt(4);
   var _5n = BigInt(5);
@@ -45793,38 +46729,38 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   var _16n = BigInt(16);
   function mod(a, b) {
     const result = a % b;
-    return result >= _0n3 ? result : b + result;
+    return result >= _0n4 ? result : b + result;
   }
   function pow(num, power, modulo) {
-    if (modulo <= _0n3 || power < _0n3)
+    if (modulo <= _0n4 || power < _0n4)
       throw new Error("Expected power/modulo > 0");
-    if (modulo === _1n3)
-      return _0n3;
-    let res = _1n3;
-    while (power > _0n3) {
-      if (power & _1n3)
+    if (modulo === _1n4)
+      return _0n4;
+    let res = _1n4;
+    while (power > _0n4) {
+      if (power & _1n4)
         res = res * num % modulo;
       num = num * num % modulo;
-      power >>= _1n3;
+      power >>= _1n4;
     }
     return res;
   }
   function pow2(x, power, modulo) {
     let res = x;
-    while (power-- > _0n3) {
+    while (power-- > _0n4) {
       res *= res;
       res %= modulo;
     }
     return res;
   }
   function invert(number3, modulo) {
-    if (number3 === _0n3 || modulo <= _0n3) {
+    if (number3 === _0n4 || modulo <= _0n4) {
       throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
     }
     let a = mod(number3, modulo);
     let b = modulo;
-    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
-    while (a !== _0n3) {
+    let x = _0n4, y = _1n4, u = _1n4, v = _0n4;
+    while (a !== _0n4) {
       const q = b / a;
       const r = b % a;
       const m = x - u * q;
@@ -45832,19 +46768,19 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       b = a, a = r, x = u, y = v, u = m, v = n;
     }
     const gcd = b;
-    if (gcd !== _1n3)
+    if (gcd !== _1n4)
       throw new Error("invert: does not exist");
     return mod(x, modulo);
   }
   function tonelliShanks(P) {
-    const legendreC = (P - _1n3) / _2n3;
+    const legendreC = (P - _1n4) / _2n4;
     let Q, S, Z;
-    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
+    for (Q = P - _1n4, S = 0; Q % _2n4 === _0n4; Q /= _2n4, S++)
       ;
-    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
+    for (Z = _2n4; Z < P && pow(Z, legendreC, P) !== P - _1n4; Z++)
       ;
     if (S === 1) {
-      const p1div4 = (P + _1n3) / _4n;
+      const p1div4 = (P + _1n4) / _4n;
       return function tonelliFast(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -45852,7 +46788,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         return root;
       };
     }
-    const Q1div2 = (Q + _1n3) / _2n3;
+    const Q1div2 = (Q + _1n4) / _2n4;
     return function tonelliSlow(Fp2, n) {
       if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
         throw new Error("Cannot find square root");
@@ -45869,7 +46805,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
             break;
           t2 = Fp2.sqr(t2);
         }
-        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
+        const ge = Fp2.pow(g, _1n4 << BigInt(r - m - 1));
         g = Fp2.sqr(ge);
         x = Fp2.mul(x, ge);
         b = Fp2.mul(b, g);
@@ -45880,7 +46816,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   }
   function FpSqrt(P) {
     if (P % _4n === _3n) {
-      const p1div4 = (P + _1n3) / _4n;
+      const p1div4 = (P + _1n4) / _4n;
       return function sqrt3mod4(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
         if (!Fp2.eql(Fp2.sqr(root), n))
@@ -45891,10 +46827,10 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     if (P % _8n === _5n) {
       const c1 = (P - _5n) / _8n;
       return function sqrt5mod8(Fp2, n) {
-        const n2 = Fp2.mul(n, _2n3);
+        const n2 = Fp2.mul(n, _2n4);
         const v = Fp2.pow(n2, c1);
         const nv = Fp2.mul(n, v);
-        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
+        const i = Fp2.mul(Fp2.mul(nv, _2n4), v);
         const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
         if (!Fp2.eql(Fp2.sqr(root), n))
           throw new Error("Cannot find square root");
@@ -45938,19 +46874,19 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     return validateObject(field, opts);
   }
   function FpPow(f2, num, power) {
-    if (power < _0n3)
+    if (power < _0n4)
       throw new Error("Expected power > 0");
-    if (power === _0n3)
+    if (power === _0n4)
       return f2.ONE;
-    if (power === _1n3)
+    if (power === _1n4)
       return num;
     let p = f2.ONE;
     let d = num;
-    while (power > _0n3) {
-      if (power & _1n3)
+    while (power > _0n4) {
+      if (power & _1n4)
         p = f2.mul(p, d);
       d = f2.sqr(d);
-      power >>= _1n3;
+      power >>= _1n4;
     }
     return p;
   }
@@ -45977,7 +46913,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     return { nBitLength: _nBitLength, nByteLength };
   }
   function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
-    if (ORDER <= _0n3)
+    if (ORDER <= _0n4)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
     if (BYTES > 2048)
@@ -45988,16 +46924,16 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       BITS,
       BYTES,
       MASK: bitMask(BITS),
-      ZERO: _0n3,
-      ONE: _1n3,
+      ZERO: _0n4,
+      ONE: _1n4,
       create: (num) => mod(num, ORDER),
       isValid: (num) => {
         if (typeof num !== "bigint")
           throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
-        return _0n3 <= num && num < ORDER;
+        return _0n4 <= num && num < ORDER;
       },
-      is0: (num) => num === _0n3,
-      isOdd: (num) => (num & _1n3) === _1n3,
+      is0: (num) => num === _0n4,
+      isOdd: (num) => (num & _1n4) === _1n4,
       neg: (num) => mod(-num, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
       sqr: (num) => mod(num * num, ORDER),
@@ -46043,13 +46979,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
     const num = isLE3 ? bytesToNumberBE(key) : bytesToNumberLE(key);
-    const reduced = mod(num, fieldOrder - _1n3) + _1n3;
+    const reduced = mod(num, fieldOrder - _1n4) + _1n4;
     return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/curve.js
-  var _0n4 = BigInt(0);
-  var _1n4 = BigInt(1);
+  var _0n5 = BigInt(0);
+  var _1n5 = BigInt(1);
   function wNAF(c, bits) {
     const constTimeNegate = (condition, item) => {
       const neg = item.negate();
@@ -46066,11 +47002,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
-        while (n > _0n4) {
-          if (n & _1n4)
+        while (n > _0n5) {
+          if (n & _1n5)
             p = p.add(d);
           d = d.double();
-          n >>= _1n4;
+          n >>= _1n5;
         }
         return p;
       },
@@ -46120,7 +47056,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           n >>= shiftBy;
           if (wbits > windowSize) {
             wbits -= maxNumber;
-            n += _1n4;
+            n += _1n5;
           }
           const offset1 = offset;
           const offset2 = offset + Math.abs(wbits) - 1;
@@ -46244,9 +47180,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
     }
   };
-  var _0n5 = BigInt(0);
-  var _1n5 = BigInt(1);
-  var _2n4 = BigInt(2);
+  var _0n6 = BigInt(0);
+  var _1n6 = BigInt(1);
+  var _2n5 = BigInt(2);
   var _3n2 = BigInt(3);
   var _4n2 = BigInt(4);
   function weierstrassPoints(opts) {
@@ -46271,7 +47207,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return typeof num === "bigint" && _0n5 < num && num < CURVE.n;
+      return typeof num === "bigint" && _0n6 < num && num < CURVE.n;
     }
     function assertGE(num) {
       if (!isWithinCurveOrder(num))
@@ -46515,10 +47451,10 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
        */
       multiplyUnsafe(n) {
         const I = Point2.ZERO;
-        if (n === _0n5)
+        if (n === _0n6)
           return I;
         assertGE(n);
-        if (n === _1n5)
+        if (n === _1n6)
           return this;
         const { endo } = CURVE;
         if (!endo)
@@ -46527,14 +47463,14 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         let k1p = I;
         let k2p = I;
         let d = this;
-        while (k1 > _0n5 || k2 > _0n5) {
-          if (k1 & _1n5)
+        while (k1 > _0n6 || k2 > _0n6) {
+          if (k1 & _1n6)
             k1p = k1p.add(d);
-          if (k2 & _1n5)
+          if (k2 & _1n6)
             k2p = k2p.add(d);
           d = d.double();
-          k1 >>= _1n5;
-          k2 >>= _1n5;
+          k1 >>= _1n6;
+          k2 >>= _1n6;
         }
         if (k1neg)
           k1p = k1p.negate();
@@ -46581,7 +47517,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
        */
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point2.BASE;
-        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
+        const mul = (P, a2) => a2 === _0n6 || a2 === _1n6 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
@@ -46604,7 +47540,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE;
-        if (cofactor === _1n5)
+        if (cofactor === _1n6)
           return true;
         if (isTorsionFree)
           return isTorsionFree(Point2, this);
@@ -46612,7 +47548,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
       clearCofactor() {
         const { h: cofactor, clearCofactor } = CURVE;
-        if (cofactor === _1n5)
+        if (cofactor === _1n6)
           return this;
         if (clearCofactor)
           return clearCofactor(Point2, this);
@@ -46657,7 +47593,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
     function isValidFieldElement(num) {
-      return _0n5 < num && num < Fp2.ORDER;
+      return _0n6 < num && num < Fp2.ORDER;
     }
     function modN(a) {
       return mod(a, CURVE_ORDER);
@@ -46687,7 +47623,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y = Fp2.sqrt(y2);
-          const isYOdd = (y & _1n5) === _1n5;
+          const isYOdd = (y & _1n6) === _1n6;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
             y = Fp2.neg(y);
@@ -46703,7 +47639,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     });
     const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
     function isBiggerThanHalfOrder(number3) {
-      const HALF = CURVE_ORDER >> _1n5;
+      const HALF = CURVE_ORDER >> _1n6;
       return number3 > HALF;
     }
     function normalizeS(s) {
@@ -46846,7 +47782,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     function int2octets(num) {
       if (typeof num !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n5 <= num && num < ORDER_MASK))
+      if (!(_0n6 <= num && num < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
       return numberToBytesBE(num, CURVE.nByteLength);
     }
@@ -46876,12 +47812,12 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         const ik = invN(k);
         const q = Point2.BASE.multiply(k).toAffine();
         const r = modN(q.x);
-        if (r === _0n5)
+        if (r === _0n6)
           return;
         const s = modN(ik * modN(m + r * d));
-        if (s === _0n5)
+        if (s === _0n6)
           return;
-        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n6);
         let normS = s;
         if (lowS && isBiggerThanHalfOrder(s)) {
           normS = normalizeS(s);
@@ -46973,9 +47909,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/secp256k1.js
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
-  var _1n6 = BigInt(1);
-  var _2n5 = BigInt(2);
-  var divNearest = (a, b) => (a + b / _2n5) / b;
+  var _1n7 = BigInt(1);
+  var _2n6 = BigInt(2);
+  var divNearest = (a, b) => (a + b / _2n6) / b;
   function sqrtMod(y) {
     const P = secp256k1P;
     const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
@@ -46984,7 +47920,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     const b3 = b2 * b2 * y % P;
     const b6 = pow2(b3, _3n3, P) * b3 % P;
     const b9 = pow2(b6, _3n3, P) * b3 % P;
-    const b11 = pow2(b9, _2n5, P) * b2 % P;
+    const b11 = pow2(b9, _2n6, P) * b2 % P;
     const b22 = pow2(b11, _11n, P) * b11 % P;
     const b44 = pow2(b22, _22n, P) * b22 % P;
     const b88 = pow2(b44, _44n, P) * b44 % P;
@@ -46993,7 +47929,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     const b223 = pow2(b220, _3n3, P) * b3 % P;
     const t1 = pow2(b223, _23n, P) * b22 % P;
     const t2 = pow2(t1, _6n, P) * b2 % P;
-    const root = pow2(t2, _2n5, P);
+    const root = pow2(t2, _2n6, P);
     if (!Fp.eql(Fp.sqr(root), y))
       throw new Error("Cannot find square root");
     return root;
@@ -47026,7 +47962,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       splitScalar: (k) => {
         const n = secp256k1N;
         const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
-        const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
+        const b1 = -_1n7 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
         const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
         const b2 = a1;
         const POW_2_128 = BigInt("0x100000000000000000000000000000000");
@@ -47047,7 +47983,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
     }
   }, sha256);
-  var _0n6 = BigInt(0);
+  var _0n7 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
   // src/signer/signer.ts
@@ -47154,12 +48090,12 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/rng.js
-  var import_crypto15 = __toESM(__require("crypto"));
+  var import_crypto16 = __toESM(__require("crypto"));
   var rnds8Pool = new Uint8Array(256);
   var poolPtr = rnds8Pool.length;
   function rng() {
     if (poolPtr > rnds8Pool.length - 16) {
-      import_crypto15.default.randomFillSync(rnds8Pool);
+      import_crypto16.default.randomFillSync(rnds8Pool);
       poolPtr = 0;
     }
     return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -47175,9 +48111,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   }
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/native.js
-  var import_crypto16 = __toESM(__require("crypto"));
+  var import_crypto17 = __toESM(__require("crypto"));
   var native_default = {
-    randomUUID: import_crypto16.default.randomUUID
+    randomUUID: import_crypto17.default.randomUUID
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/v4.js
@@ -50115,16 +51051,21 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
   // src/test-utils/seedTestWallet.ts
-  var seedTestWallet = async (wallet, quantities) => {
+  var seedTestWallet = async (wallet, quantities, utxosAmount = 1) => {
+    const toFundAccounts = Array.isArray(wallet) ? wallet : [wallet];
     const genesisWallet = new WalletUnlocked(
       process.env.GENESIS_SECRET || randomBytes22(32),
-      wallet.provider
+      // Connect to the same Provider as wallet
+      toFundAccounts[0].provider
     );
     const request = new ScriptTransactionRequest();
-    quantities.forEach((quantity) => {
-      const { amount, assetId } = coinQuantityfy(quantity);
-      request.addCoinOutput(wallet.address, amount, assetId);
-    });
+    quantities.map(coinQuantityfy).forEach(
+      ({ amount, assetId }) => toFundAccounts.forEach(({ address }) => {
+        for (let i = 0; i < utxosAmount; i++) {
+          request.addCoinOutput(address, amount.div(utxosAmount), assetId);
+        }
+      })
+    );
     const txCost = await genesisWallet.provider.getTransactionCost(request);
     request.gasLimit = txCost.gasUsed;
     request.maxFee = txCost.maxFee;
@@ -50158,7 +51099,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
 
   // src/test-utils/launchNode.ts
   var import_child_process = __require("child_process");
-  var import_crypto21 = __require("crypto");
+  var import_crypto22 = __require("crypto");
   var import_fs2 = __require("fs");
   var import_os = __toESM(__require("os"));
   var import_path8 = __toESM(__require("path"));
@@ -50230,7 +51171,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       })).toString();
       let snapshotDirToUse;
       const prefix = basePath || import_os.default.tmpdir();
-      const suffix = basePath ? "" : (0, import_crypto21.randomUUID)();
+      const suffix = basePath ? "" : (0, import_crypto22.randomUUID)();
       const tempDirPath = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
       if (snapshotDir) {
         snapshotDirToUse = snapshotDir;
@@ -50357,6 +51298,33 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     };
     return { wallets, stop: cleanup, provider };
   };
+
+  // src/test-utils/transactionRequest.ts
+  var generateFakeRequestInputCoin = (partial = {}) => ({
+    id: hexlify(randomBytes22(UTXO_ID_LEN)),
+    type: InputType.Coin,
+    owner: getRandomB256(),
+    amount: bn(100),
+    assetId: ZeroBytes32,
+    txPointer: "0x00000000000000000000000000000000",
+    witnessIndex: 0,
+    ...partial
+  });
+  var generateFakeRequestInputMessage = (partial = {}) => ({
+    nonce: getRandomB256(),
+    type: InputType.Message,
+    sender: getRandomB256(),
+    recipient: getRandomB256(),
+    amount: bn(100),
+    witnessIndex: 0,
+    ...partial
+  });
+  var generateFakeRequestInputContract = (partial = {}) => ({
+    contractId: getRandomB256(),
+    type: InputType.Contract,
+    txPointer: "0x00000000000000000000000000000000",
+    ...partial
+  });
 })();
 /*! Bundled license information: