@fuel-ts/account 0.0.0-rc-2152-20240425194419 → 0.0.0-rc-2021-20240425202957

package/dist/index.global.js

@@ -182,13 +182,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);
@@ -289,7 +289,7 @@
           }
           return num !== null && typeof num === "object" && num.constructor.wordSize === BN2.wordSize && Array.isArray(num.words);
         };
-        BN2.max = function max2(left, right) {
+        BN2.max = function max(left, right) {
           if (left.cmp(right) > 0)
             return left;
           return right;
@@ -1089,7 +1089,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;
@@ -2803,7 +2803,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) {
@@ -2817,7 +2817,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++) {
@@ -2953,7 +2953,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) {
@@ -5113,7 +5113,7 @@
   function isBlob(obj) {
     return typeof obj === "object" && typeof obj.arrayBuffer === "function" && typeof obj.type === "string" && typeof obj.stream === "function" && typeof obj.constructor === "function" && typeof obj.constructor.name === "string" && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
   }
-  function clone(instance) {
+  function clone3(instance) {
     let p1, p2;
     let body = instance.body;
     if (instance.bodyUsed) {
@@ -6047,7 +6047,7 @@
          * @return  Response
          */
         clone() {
-          return new Response2(clone(this), {
+          return new Response2(clone3(this), {
             url: this.url,
             status: this.status,
             statusText: this.statusText,
@@ -6097,7 +6097,7 @@
           if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
             throw new TypeError("Request with GET/HEAD method cannot have body");
           }
-          let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
+          let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone3(input) : null;
           Body.call(this, inputBody, {
             timeout: init.timeout || input.timeout || 0,
             size: init.size || input.size || 0
@@ -20417,7 +20417,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);
       }
@@ -27996,7 +27996,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;
@@ -28236,9 +28236,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;
@@ -28953,7 +28953,7 @@ spurious results.`);
   function getBuiltinVersions() {
     return {
       FORC: "0.55.0",
-      FUEL_CORE: "0.22.1",
+      FUEL_CORE: "0.24.3",
       FUELS: "0.82.0"
     };
   }
@@ -29053,6 +29053,7 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_TRANSFER_AMOUNT"] = "invalid-transfer-amount";
     ErrorCode2["GAS_PRICE_TOO_LOW"] = "gas-price-too-low";
     ErrorCode2["GAS_LIMIT_TOO_LOW"] = "gas-limit-too-low";
+    ErrorCode2["MAX_FEE_TOO_LOW"] = "max-fee-too-low";
     ErrorCode2["TRANSACTION_NOT_FOUND"] = "transaction-not-found";
     ErrorCode2["TRANSACTION_FAILED"] = "transaction-failed";
     ErrorCode2["INVALID_CONFIGURABLE_CONSTANTS"] = "invalid-configurable-constants";
@@ -29243,9 +29244,12 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var DateTime = _DateTime;
   __publicField3(DateTime, "TAI64_NULL", "");
+  function isDefined(value) {
+    return value !== void 0;
+  }
 
   // ../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";
@@ -29412,6 +29416,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);
@@ -29772,7 +29788,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)
@@ -29805,14 +29888,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;
@@ -29984,7 +30277,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);
   };
@@ -29995,10 +30288,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;
@@ -30006,7 +30299,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);
   };
@@ -30018,19 +30311,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 });
@@ -30039,7 +30915,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);
@@ -30054,7 +30930,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 {
@@ -30068,7 +30944,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");
@@ -30079,12 +30955,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);
   }
@@ -30619,32 +31495,182 @@ This unreleased fuel-core build may include features and updates not yet support
   function toBytes3(value, bytesPadding) {
     return bn(value).toBytes(bytesPadding);
   }
-  function max(...numbers) {
-    return numbers.reduce((prev, cur) => bn(cur).gt(prev) ? bn(cur) : prev, bn(0));
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isPlaceholder.js
+  function _isPlaceholder(a) {
+    return a != null && typeof a === "object" && a["@@functional/placeholder"] === true;
+  }
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry1.js
+  function _curry1(fn) {
+    return function f1(a) {
+      if (arguments.length === 0 || _isPlaceholder(a)) {
+        return f1;
+      } else {
+        return fn.apply(this, arguments);
+      }
+    };
   }
 
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isArray.js
+  var isArray_default = Array.isArray || function _isArray(val) {
+    return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
+  };
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/type.js
+  var type = /* @__PURE__ */ _curry1(function type2(val) {
+    return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+  });
+  var type_default = type;
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_toISOString.js
+  var pad = function pad2(n) {
+    return (n < 10 ? "0" : "") + n;
+  };
+  var _toISOString = typeof Date.prototype.toISOString === "function" ? function _toISOString2(d) {
+    return d.toISOString();
+  } : function _toISOString3(d) {
+    return d.getUTCFullYear() + "-" + pad(d.getUTCMonth() + 1) + "-" + pad(d.getUTCDate()) + "T" + pad(d.getUTCHours()) + ":" + pad(d.getUTCMinutes()) + ":" + pad(d.getUTCSeconds()) + "." + (d.getUTCMilliseconds() / 1e3).toFixed(3).slice(2, 5) + "Z";
+  };
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isInteger.js
+  var isInteger_default = Number.isInteger || function _isInteger(n) {
+    return n << 0 === n;
+  };
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_cloneRegExp.js
+  function _cloneRegExp(pattern) {
+    return new RegExp(pattern.source, pattern.flags ? pattern.flags : (pattern.global ? "g" : "") + (pattern.ignoreCase ? "i" : "") + (pattern.multiline ? "m" : "") + (pattern.sticky ? "y" : "") + (pattern.unicode ? "u" : "") + (pattern.dotAll ? "s" : ""));
+  }
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_clone.js
+  function _clone(value, deep, map) {
+    map || (map = new _ObjectMap());
+    if (_isPrimitive(value)) {
+      return value;
+    }
+    var copy = function copy2(copiedValue) {
+      var cachedCopy = map.get(value);
+      if (cachedCopy) {
+        return cachedCopy;
+      }
+      map.set(value, copiedValue);
+      for (var key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          copiedValue[key] = deep ? _clone(value[key], true, map) : value[key];
+        }
+      }
+      return copiedValue;
+    };
+    switch (type_default(value)) {
+      case "Object":
+        return copy(Object.create(Object.getPrototypeOf(value)));
+      case "Array":
+        return copy([]);
+      case "Date":
+        return new Date(value.valueOf());
+      case "RegExp":
+        return _cloneRegExp(value);
+      case "Int8Array":
+      case "Uint8Array":
+      case "Uint8ClampedArray":
+      case "Int16Array":
+      case "Uint16Array":
+      case "Int32Array":
+      case "Uint32Array":
+      case "Float32Array":
+      case "Float64Array":
+      case "BigInt64Array":
+      case "BigUint64Array":
+        return value.slice();
+      default:
+        return value;
+    }
+  }
+  function _isPrimitive(param) {
+    var type3 = typeof param;
+    return param == null || type3 != "object" && type3 != "function";
+  }
+  var _ObjectMap = /* @__PURE__ */ function() {
+    function _ObjectMap2() {
+      this.map = {};
+      this.length = 0;
+    }
+    _ObjectMap2.prototype.set = function(key, value) {
+      const hashedKey = this.hash(key);
+      let bucket = this.map[hashedKey];
+      if (!bucket) {
+        this.map[hashedKey] = bucket = [];
+      }
+      bucket.push([key, value]);
+      this.length += 1;
+    };
+    _ObjectMap2.prototype.hash = function(key) {
+      let hashedKey = [];
+      for (var value in key) {
+        hashedKey.push(Object.prototype.toString.call(key[value]));
+      }
+      return hashedKey.join();
+    };
+    _ObjectMap2.prototype.get = function(key) {
+      if (this.length <= 180) {
+        for (const p in this.map) {
+          const bucket2 = this.map[p];
+          for (let i = 0; i < bucket2.length; i += 1) {
+            const element = bucket2[i];
+            if (element[0] === key) {
+              return element[1];
+            }
+          }
+        }
+        return;
+      }
+      const hashedKey = this.hash(key);
+      const bucket = this.map[hashedKey];
+      if (!bucket) {
+        return;
+      }
+      for (let i = 0; i < bucket.length; i += 1) {
+        const element = bucket[i];
+        if (element[0] === key) {
+          return element[1];
+        }
+      }
+    };
+    return _ObjectMap2;
+  }();
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/clone.js
+  var clone = /* @__PURE__ */ _curry1(function clone2(value) {
+    return value != null && typeof value.clone === "function" ? value.clone() : _clone(value, true);
+  });
+  var clone_default = clone;
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/trim.js
+  var hasProtoTrim = typeof String.prototype.trim === "function";
+
   // src/providers/coin-quantity.ts
   var coinQuantityfy = (coinQuantityLike) => {
     let assetId;
     let amount;
-    let max2;
+    let max;
     if (Array.isArray(coinQuantityLike)) {
       amount = coinQuantityLike[0];
       assetId = coinQuantityLike[1];
-      max2 = coinQuantityLike[2] ?? void 0;
+      max = coinQuantityLike[2] ?? void 0;
     } else {
       amount = coinQuantityLike.amount;
       assetId = coinQuantityLike.assetId;
-      max2 = coinQuantityLike.max ?? void 0;
+      max = coinQuantityLike.max ?? void 0;
     }
     const bnAmount = bn(amount);
     return {
       assetId: hexlify(assetId),
       amount: bnAmount.lt(1) ? bn(1) : bnAmount,
-      max: max2 ? bn(max2) : void 0
+      max: max ? bn(max) : void 0
     };
   };
-  var addAmountToAsset = (params) => {
+  var addAmountToCoinQuantities = (params) => {
     const { amount, assetId } = params;
     const coinQuantities = [...params.coinQuantities];
     const assetIdx = coinQuantities.findIndex((coinQuantity) => coinQuantity.assetId === assetId);
@@ -30729,7 +31755,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
-  var UTXO_ID_LEN = BYTES_32 + 1;
+  var UTXO_ID_LEN = BYTES_32 + 2;
   var ASSET_ID_LEN = BYTES_32;
   var ADDRESS_LEN = BYTES_32;
   var NONCE_LEN = BYTES_32;
@@ -30737,9 +31763,9 @@ This unreleased fuel-core build may include features and updates not yet support
   var TX_POINTER_LEN = WORD_SIZE * 2;
   var MAX_BYTES = 2 ** 32 - 1;
   var calculateVmTxMemory = ({ maxInputs }) => BYTES_32 + // Tx ID
-  WORD_SIZE + // Tx size
+  ASSET_ID_LEN + // Base asset ID
   // Asset ID/Balance coin input pairs
-  maxInputs * (ASSET_ID_LEN + WORD_SIZE);
+  maxInputs * (ASSET_ID_LEN + WORD_SIZE) + WORD_SIZE;
   var SCRIPT_FIXED_SIZE = WORD_SIZE + // Identifier
   WORD_SIZE + // Gas limit
   WORD_SIZE + // Script size
@@ -30757,7 +31783,6 @@ This unreleased fuel-core build may include features and updates not yet support
   ASSET_ID_LEN + // Asset id
   TX_POINTER_LEN + // TxPointer
   WORD_SIZE + // Witnesses index
-  WORD_SIZE + // Maturity
   WORD_SIZE + // Predicate size
   WORD_SIZE + // Predicate data size
   WORD_SIZE;
@@ -31079,7 +32104,7 @@ This unreleased fuel-core build may include features and updates not yet support
     constructor(name, coders) {
       const caseIndexCoder = new BigNumberCoder("u64");
       const encodedValueSize = Object.values(coders).reduce(
-        (max2, coder) => Math.max(max2, coder.encodedLength),
+        (max, coder) => Math.max(max, coder.encodedLength),
         0
       );
       super(`enum ${name}`, `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
@@ -31797,7 +32822,7 @@ This unreleased fuel-core build may include features and updates not yet support
     constructor(name, coders) {
       const caseIndexCoder = new BigNumberCoder("u64");
       const encodedValueSize = Object.values(coders).reduce(
-        (max2, coder) => Math.max(max2, coder.encodedLength),
+        (max, coder) => Math.max(max, coder.encodedLength),
         0
       );
       super(`enum ${name}`, `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
@@ -32515,18 +33540,19 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u8").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.owner));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
       parts.push(new TxPointerCoder().encode(value.txPointer));
-      parts.push(new NumberCoder("u8").encode(value.witnessIndex));
-      parts.push(new NumberCoder("u32").encode(value.maturity));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
-      parts.push(new NumberCoder("u32").encode(value.predicateLength));
-      parts.push(new NumberCoder("u32").encode(value.predicateDataLength));
-      parts.push(new ByteArrayCoder(value.predicateLength).encode(value.predicate));
-      parts.push(new ByteArrayCoder(value.predicateDataLength).encode(value.predicateData));
+      parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
+      parts.push(new BigNumberCoder("u64").encode(value.predicateDataLength));
+      parts.push(new ByteArrayCoder(value.predicateLength.toNumber()).encode(value.predicate));
+      parts.push(
+        new ByteArrayCoder(value.predicateDataLength.toNumber()).encode(value.predicateData)
+      );
       return concat(parts);
     }
     decode(data, offset) {
@@ -32534,7 +33560,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const owner = decoded;
@@ -32544,19 +33570,17 @@ This unreleased fuel-core build may include features and updates not yet support
       const assetId = decoded;
       [decoded, o] = new TxPointerCoder().decode(data, o);
       const txPointer = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
-      const maturity = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateDataLength = decoded;
-      [decoded, o] = new ByteArrayCoder(predicateLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(predicateLength.toNumber()).decode(data, o);
       const predicate = decoded;
-      [decoded, o] = new ByteArrayCoder(predicateDataLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(predicateDataLength.toNumber()).decode(data, o);
       const predicateData = decoded;
       return [
         {
@@ -32568,7 +33592,6 @@ This unreleased fuel-core build may include features and updates not yet support
           assetId,
           txPointer,
           witnessIndex,
-          maturity,
           predicateGasUsed,
           predicateLength,
           predicateDataLength,
@@ -32586,7 +33609,7 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u8").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
@@ -32598,7 +33621,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -32647,14 +33670,16 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
-      parts.push(new NumberCoder("u8").encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
-      parts.push(new NumberCoder("u32").encode(data.length));
-      parts.push(new NumberCoder("u32").encode(value.predicateLength));
-      parts.push(new NumberCoder("u32").encode(value.predicateDataLength));
+      parts.push(new BigNumberCoder("u64").encode(data.length));
+      parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
+      parts.push(new BigNumberCoder("u64").encode(value.predicateDataLength));
       parts.push(new ByteArrayCoder(data.length).encode(data));
-      parts.push(new ByteArrayCoder(value.predicateLength).encode(value.predicate));
-      parts.push(new ByteArrayCoder(value.predicateDataLength).encode(value.predicateData));
+      parts.push(new ByteArrayCoder(value.predicateLength.toNumber()).encode(value.predicate));
+      parts.push(
+        new ByteArrayCoder(value.predicateDataLength.toNumber()).encode(value.predicateData)
+      );
       return concat(parts);
     }
     static decodeData(messageData) {
@@ -32674,21 +33699,21 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
       const dataLength2 = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateDataLength = decoded;
       [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
       const messageData = decoded;
-      [decoded, o] = new ByteArrayCoder(predicateLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(predicateLength.toNumber()).decode(data, o);
       const predicate = decoded;
-      [decoded, o] = new ByteArrayCoder(predicateDataLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(predicateDataLength.toNumber()).decode(data, o);
       const predicateData = decoded;
       return [
         {
@@ -33000,7 +34025,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   var PolicyType = /* @__PURE__ */ ((PolicyType2) => {
-    PolicyType2[PolicyType2["GasPrice"] = 1] = "GasPrice";
+    PolicyType2[PolicyType2["Tip"] = 1] = "Tip";
     PolicyType2[PolicyType2["WitnessLimit"] = 2] = "WitnessLimit";
     PolicyType2[PolicyType2["Maturity"] = 4] = "Maturity";
     PolicyType2[PolicyType2["MaxFee"] = 8] = "MaxFee";
@@ -33048,9 +34073,9 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       const policies = [];
       if (policyTypes & 1) {
-        const [gasPrice, nextOffset] = new BigNumberCoder("u64").decode(data, o);
+        const [tip, nextOffset] = new BigNumberCoder("u64").decode(data, o);
         o = nextOffset;
-        policies.push({ type: 1, data: gasPrice });
+        policies.push({ type: 1, data: tip });
       }
       if (policyTypes & 2) {
         const [witnessLimit, nextOffset] = new BigNumberCoder("u64").decode(data, o);
@@ -33282,15 +34307,15 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new BigNumberCoder("u64").encode(value.scriptGasLimit));
-      parts.push(new NumberCoder("u32").encode(value.scriptLength));
-      parts.push(new NumberCoder("u32").encode(value.scriptDataLength));
-      parts.push(new NumberCoder("u32").encode(value.policyTypes));
-      parts.push(new NumberCoder("u8").encode(value.inputsCount));
-      parts.push(new NumberCoder("u8").encode(value.outputsCount));
-      parts.push(new NumberCoder("u8").encode(value.witnessesCount));
       parts.push(new B256Coder().encode(value.receiptsRoot));
-      parts.push(new ByteArrayCoder(value.scriptLength).encode(value.script));
-      parts.push(new ByteArrayCoder(value.scriptDataLength).encode(value.scriptData));
+      parts.push(new BigNumberCoder("u64").encode(value.scriptLength));
+      parts.push(new BigNumberCoder("u64").encode(value.scriptDataLength));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
+      parts.push(new ByteArrayCoder(value.scriptLength.toNumber()).encode(value.script));
+      parts.push(new ByteArrayCoder(value.scriptDataLength.toNumber()).encode(value.scriptData));
       parts.push(new PoliciesCoder().encode(value.policies));
       parts.push(new ArrayCoder(new InputCoder(), value.inputsCount).encode(value.inputs));
       parts.push(new ArrayCoder(new OutputCoder(), value.outputsCount).encode(value.outputs));
@@ -33302,23 +34327,23 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptGasLimit = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new B256Coder().decode(data, o);
+      const receiptsRoot = decoded;
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptLength = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptDataLength = decoded;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
-      [decoded, o] = new B256Coder().decode(data, o);
-      const receiptsRoot = decoded;
-      [decoded, o] = new ByteArrayCoder(scriptLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(scriptLength.toNumber()).decode(data, o);
       const script = decoded;
-      [decoded, o] = new ByteArrayCoder(scriptDataLength).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(scriptDataLength.toNumber()).decode(data, o);
       const scriptData = decoded;
       [decoded, o] = new PoliciesCoder().decode(data, o, policyTypes);
       const policies = decoded;
@@ -33356,18 +34381,19 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u32").encode(value.bytecodeLength));
-      parts.push(new NumberCoder("u8").encode(value.bytecodeWitnessIndex));
-      parts.push(new NumberCoder("u32").encode(value.policyTypes));
-      parts.push(new NumberCoder("u16").encode(value.storageSlotsCount));
-      parts.push(new NumberCoder("u8").encode(value.inputsCount));
-      parts.push(new NumberCoder("u8").encode(value.outputsCount));
-      parts.push(new NumberCoder("u8").encode(value.witnessesCount));
+      parts.push(new NumberCoder("u16").encode(value.bytecodeWitnessIndex));
       parts.push(new B256Coder().encode(value.salt));
-      parts.push(new PoliciesCoder().encode(value.policies));
+      parts.push(new BigNumberCoder("u64").encode(value.storageSlotsCount));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
       parts.push(
-        new ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount).encode(value.storageSlots)
+        new ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount.toNumber()).encode(
+          value.storageSlots
+        )
       );
+      parts.push(new PoliciesCoder().encode(value.policies));
       parts.push(new ArrayCoder(new InputCoder(), value.inputsCount).encode(value.inputs));
       parts.push(new ArrayCoder(new OutputCoder(), value.outputsCount).encode(value.outputs));
       parts.push(new ArrayCoder(new WitnessCoder(), value.witnessesCount).encode(value.witnesses));
@@ -33376,26 +34402,27 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
-      const bytecodeLength = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const bytecodeWitnessIndex = decoded;
+      [decoded, o] = new B256Coder().decode(data, o);
+      const salt = decoded;
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
+      const storageSlotsCount = decoded;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
       [decoded, o] = new NumberCoder("u16").decode(data, o);
-      const storageSlotsCount = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
-      [decoded, o] = new B256Coder().decode(data, o);
-      const salt = decoded;
+      [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount.toNumber()).decode(
+        data,
+        o
+      );
+      const storageSlots = decoded;
       [decoded, o] = new PoliciesCoder().decode(data, o, policyTypes);
       const policies = decoded;
-      [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount).decode(data, o);
-      const storageSlots = decoded;
       [decoded, o] = new ArrayCoder(new InputCoder(), inputsCount).decode(data, o);
       const inputs = decoded;
       [decoded, o] = new ArrayCoder(new OutputCoder(), outputsCount).decode(data, o);
@@ -33405,7 +34432,6 @@ This unreleased fuel-core build may include features and updates not yet support
       return [
         {
           type: 1,
-          bytecodeLength,
           bytecodeWitnessIndex,
           policyTypes,
           storageSlotsCount,
@@ -33434,6 +34460,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new OutputContractCoder().encode(value.outputContract));
       parts.push(new BigNumberCoder("u64").encode(value.mintAmount));
       parts.push(new B256Coder().encode(value.mintAssetId));
+      parts.push(new BigNumberCoder("u64").encode(value.gasPrice));
       return concat(parts);
     }
     decode(data, offset) {
@@ -33449,6 +34476,8 @@ This unreleased fuel-core build may include features and updates not yet support
       const mintAmount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const mintAssetId = decoded;
+      [decoded, o] = new BigNumberCoder("u64").decode(data, o);
+      const gasPrice = decoded;
       return [
         {
           type: 2,
@@ -33456,7 +34485,8 @@ This unreleased fuel-core build may include features and updates not yet support
           inputContract,
           outputContract,
           mintAmount,
-          mintAssetId
+          mintAssetId,
+          gasPrice
         },
         o
       ];
@@ -33548,9 +34578,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";
   }
@@ -33669,17 +34699,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) {
@@ -33706,7 +34736,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;
@@ -33723,7 +34753,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;
@@ -33763,159 +34793,6 @@ This unreleased fuel-core build may include features and updates not yet support
   // src/providers/provider.ts
   var import_graphql_request = __toESM(require_dist2());
 
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isPlaceholder.js
-  function _isPlaceholder(a) {
-    return a != null && typeof a === "object" && a["@@functional/placeholder"] === true;
-  }
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry1.js
-  function _curry1(fn) {
-    return function f1(a) {
-      if (arguments.length === 0 || _isPlaceholder(a)) {
-        return f1;
-      } else {
-        return fn.apply(this, arguments);
-      }
-    };
-  }
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isArray.js
-  var isArray_default = Array.isArray || function _isArray(val) {
-    return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
-  };
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/type.js
-  var type = /* @__PURE__ */ _curry1(function type2(val) {
-    return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
-  });
-  var type_default = type;
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_toISOString.js
-  var pad = function pad2(n) {
-    return (n < 10 ? "0" : "") + n;
-  };
-  var _toISOString = typeof Date.prototype.toISOString === "function" ? function _toISOString2(d) {
-    return d.toISOString();
-  } : function _toISOString3(d) {
-    return d.getUTCFullYear() + "-" + pad(d.getUTCMonth() + 1) + "-" + pad(d.getUTCDate()) + "T" + pad(d.getUTCHours()) + ":" + pad(d.getUTCMinutes()) + ":" + pad(d.getUTCSeconds()) + "." + (d.getUTCMilliseconds() / 1e3).toFixed(3).slice(2, 5) + "Z";
-  };
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isInteger.js
-  var isInteger_default = Number.isInteger || function _isInteger(n) {
-    return n << 0 === n;
-  };
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_cloneRegExp.js
-  function _cloneRegExp(pattern) {
-    return new RegExp(pattern.source, pattern.flags ? pattern.flags : (pattern.global ? "g" : "") + (pattern.ignoreCase ? "i" : "") + (pattern.multiline ? "m" : "") + (pattern.sticky ? "y" : "") + (pattern.unicode ? "u" : "") + (pattern.dotAll ? "s" : ""));
-  }
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_clone.js
-  function _clone(value, deep, map) {
-    map || (map = new _ObjectMap());
-    if (_isPrimitive(value)) {
-      return value;
-    }
-    var copy = function copy2(copiedValue) {
-      var cachedCopy = map.get(value);
-      if (cachedCopy) {
-        return cachedCopy;
-      }
-      map.set(value, copiedValue);
-      for (var key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-          copiedValue[key] = deep ? _clone(value[key], true, map) : value[key];
-        }
-      }
-      return copiedValue;
-    };
-    switch (type_default(value)) {
-      case "Object":
-        return copy(Object.create(Object.getPrototypeOf(value)));
-      case "Array":
-        return copy([]);
-      case "Date":
-        return new Date(value.valueOf());
-      case "RegExp":
-        return _cloneRegExp(value);
-      case "Int8Array":
-      case "Uint8Array":
-      case "Uint8ClampedArray":
-      case "Int16Array":
-      case "Uint16Array":
-      case "Int32Array":
-      case "Uint32Array":
-      case "Float32Array":
-      case "Float64Array":
-      case "BigInt64Array":
-      case "BigUint64Array":
-        return value.slice();
-      default:
-        return value;
-    }
-  }
-  function _isPrimitive(param) {
-    var type3 = typeof param;
-    return param == null || type3 != "object" && type3 != "function";
-  }
-  var _ObjectMap = /* @__PURE__ */ function() {
-    function _ObjectMap2() {
-      this.map = {};
-      this.length = 0;
-    }
-    _ObjectMap2.prototype.set = function(key, value) {
-      const hashedKey = this.hash(key);
-      let bucket = this.map[hashedKey];
-      if (!bucket) {
-        this.map[hashedKey] = bucket = [];
-      }
-      bucket.push([key, value]);
-      this.length += 1;
-    };
-    _ObjectMap2.prototype.hash = function(key) {
-      let hashedKey = [];
-      for (var value in key) {
-        hashedKey.push(Object.prototype.toString.call(key[value]));
-      }
-      return hashedKey.join();
-    };
-    _ObjectMap2.prototype.get = function(key) {
-      if (this.length <= 180) {
-        for (const p in this.map) {
-          const bucket2 = this.map[p];
-          for (let i = 0; i < bucket2.length; i += 1) {
-            const element = bucket2[i];
-            if (element[0] === key) {
-              return element[1];
-            }
-          }
-        }
-        return;
-      }
-      const hashedKey = this.hash(key);
-      const bucket = this.map[hashedKey];
-      if (!bucket) {
-        return;
-      }
-      for (let i = 0; i < bucket.length; i += 1) {
-        const element = bucket[i];
-        if (element[0] === key) {
-          return element[1];
-        }
-      }
-    };
-    return _ObjectMap2;
-  }();
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/clone.js
-  var clone2 = /* @__PURE__ */ _curry1(function clone3(value) {
-    return value != null && typeof value.clone === "function" ? value.clone() : _clone(value, true);
-  });
-  var clone_default = clone2;
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/trim.js
-  var hasProtoTrim = typeof String.prototype.trim === "function";
-
   // ../../node_modules/.pnpm/tslib@2.6.0/node_modules/tslib/tslib.es6.mjs
   var __assign = function() {
     __assign = Object.assign || function __assign2(t) {
@@ -37081,16 +37958,20 @@ spurious results.`);
   var lib_default2 = gql;
 
   // src/providers/__generated__/operations.ts
+  var TransactionStatusSubscriptionFragmentFragmentDoc = lib_default2`
+    fragment transactionStatusSubscriptionFragment on TransactionStatus {
+  type: __typename
+  ... on SqueezedOutStatus {
+    reason
+  }
+}
+    `;
   var ReceiptFragmentFragmentDoc = lib_default2`
     fragment receiptFragment on Receipt {
-  contract {
-    id
-  }
+  id
   pc
   is
-  to {
-    id
-  }
+  to
   toAddress
   amount
   assetId
@@ -37128,10 +38009,16 @@ spurious results.`);
       id
     }
     time
+    receipts {
+      ...receiptFragment
+    }
     programState {
       returnType
       data
     }
+    receipts {
+      ...receiptFragment
+    }
   }
   ... on FailureStatus {
     block {
@@ -37139,26 +38026,24 @@ spurious results.`);
     }
     time
     reason
+    receipts {
+      ...receiptFragment
+    }
   }
   ... on SqueezedOutStatus {
     reason
   }
 }
-    `;
+    ${ReceiptFragmentFragmentDoc}`;
   var TransactionFragmentFragmentDoc = lib_default2`
     fragment transactionFragment on Transaction {
   id
   rawPayload
-  gasPrice
-  receipts {
-    ...receiptFragment
-  }
   status {
     ...transactionStatusFragment
   }
 }
-    ${ReceiptFragmentFragmentDoc}
-${TransactionStatusFragmentFragmentDoc}`;
+    ${TransactionStatusFragmentFragmentDoc}`;
   var InputEstimatePredicatesFragmentFragmentDoc = lib_default2`
     fragment inputEstimatePredicatesFragment on Input {
   ... on InputCoin {
@@ -37176,6 +38061,46 @@ ${TransactionStatusFragmentFragmentDoc}`;
   }
 }
     ${InputEstimatePredicatesFragmentFragmentDoc}`;
+  var DryRunFailureStatusFragmentFragmentDoc = lib_default2`
+    fragment dryRunFailureStatusFragment on DryRunFailureStatus {
+  reason
+  programState {
+    returnType
+    data
+  }
+}
+    `;
+  var DryRunSuccessStatusFragmentFragmentDoc = lib_default2`
+    fragment dryRunSuccessStatusFragment on DryRunSuccessStatus {
+  programState {
+    returnType
+    data
+  }
+}
+    `;
+  var DryRunTransactionStatusFragmentFragmentDoc = lib_default2`
+    fragment dryRunTransactionStatusFragment on DryRunTransactionStatus {
+  ... on DryRunFailureStatus {
+    ...dryRunFailureStatusFragment
+  }
+  ... on DryRunSuccessStatus {
+    ...dryRunSuccessStatusFragment
+  }
+}
+    ${DryRunFailureStatusFragmentFragmentDoc}
+${DryRunSuccessStatusFragmentFragmentDoc}`;
+  var DryRunTransactionExecutionStatusFragmentFragmentDoc = lib_default2`
+    fragment dryRunTransactionExecutionStatusFragment on DryRunTransactionExecutionStatus {
+  id
+  status {
+    ...dryRunTransactionStatusFragment
+  }
+  receipts {
+    ...receiptFragment
+  }
+}
+    ${DryRunTransactionStatusFragmentFragmentDoc}
+${ReceiptFragmentFragmentDoc}`;
   var CoinFragmentFragmentDoc = lib_default2`
     fragment coinFragment on Coin {
   __typename
@@ -37183,7 +38108,6 @@ ${TransactionStatusFragmentFragmentDoc}`;
   owner
   amount
   assetId
-  maturity
   blockCreated
   txCreatedIdx
 }
@@ -37222,26 +38146,32 @@ ${TransactionStatusFragmentFragmentDoc}`;
   messageBlockHeader {
     id
     daHeight
+    consensusParametersVersion
+    stateTransitionBytecodeVersion
     transactionsCount
+    messageReceiptCount
     transactionsRoot
+    messageOutboxRoot
+    eventInboxRoot
     height
     prevRoot
     time
     applicationHash
-    messageReceiptRoot
-    messageReceiptCount
   }
   commitBlockHeader {
     id
     daHeight
+    consensusParametersVersion
+    stateTransitionBytecodeVersion
     transactionsCount
+    messageReceiptCount
     transactionsRoot
+    messageOutboxRoot
+    eventInboxRoot
     height
     prevRoot
     time
     applicationHash
-    messageReceiptRoot
-    messageReceiptCount
   }
   sender
   recipient
@@ -37260,8 +38190,8 @@ ${TransactionStatusFragmentFragmentDoc}`;
   var BlockFragmentFragmentDoc = lib_default2`
     fragment blockFragment on Block {
   id
+  height
   header {
-    height
     time
   }
   transactions {
@@ -37271,6 +38201,7 @@ ${TransactionStatusFragmentFragmentDoc}`;
     `;
   var TxParametersFragmentFragmentDoc = lib_default2`
     fragment TxParametersFragment on TxParameters {
+  version
   maxInputs
   maxOutputs
   maxWitnesses
@@ -37280,6 +38211,7 @@ ${TransactionStatusFragmentFragmentDoc}`;
     `;
   var PredicateParametersFragmentFragmentDoc = lib_default2`
     fragment PredicateParametersFragment on PredicateParameters {
+  version
   maxPredicateLength
   maxPredicateDataLength
   maxGasPerPredicate
@@ -37288,18 +38220,21 @@ ${TransactionStatusFragmentFragmentDoc}`;
     `;
   var ScriptParametersFragmentFragmentDoc = lib_default2`
     fragment ScriptParametersFragment on ScriptParameters {
+  version
   maxScriptLength
   maxScriptDataLength
 }
     `;
   var ContractParametersFragmentFragmentDoc = lib_default2`
     fragment ContractParametersFragment on ContractParameters {
+  version
   contractMaxSize
   maxStorageSlots
 }
     `;
   var FeeParametersFragmentFragmentDoc = lib_default2`
     fragment FeeParametersFragment on FeeParameters {
+  version
   gasPriceFactor
   gasPerByte
 }
@@ -37319,6 +38254,7 @@ ${TransactionStatusFragmentFragmentDoc}`;
     `;
   var GasCostsFragmentFragmentDoc = lib_default2`
     fragment GasCostsFragment on GasCosts {
+  version
   add
   addi
   aloc
@@ -37331,7 +38267,6 @@ ${TransactionStatusFragmentFragmentDoc}`;
   cb
   cfei
   cfsi
-  croo
   div
   divi
   ecr1
@@ -37414,6 +38349,9 @@ ${TransactionStatusFragmentFragmentDoc}`;
   ccp {
     ...DependentCostFragment
   }
+  croo {
+    ...DependentCostFragment
+  }
   csiz {
     ...DependentCostFragment
   }
@@ -37473,6 +38411,7 @@ ${TransactionStatusFragmentFragmentDoc}`;
     ${DependentCostFragmentFragmentDoc}`;
   var ConsensusParametersFragmentFragmentDoc = lib_default2`
     fragment consensusParametersFragment on ConsensusParameters {
+  version
   txParams {
     ...TxParametersFragment
   }
@@ -37532,18 +38471,9 @@ ${ConsensusParametersFragmentFragmentDoc}`;
     fragment nodeInfoFragment on NodeInfo {
   utxoValidation
   vmBacktrace
-  minGasPrice
   maxTx
   maxDepth
   nodeVersion
-  peers {
-    id
-    addresses
-    clientVersion
-    blockHeight
-    lastHeartbeatMs
-    appScore
-  }
 }
     `;
   var GetVersionDocument = lib_default2`
@@ -37578,13 +38508,9 @@ ${ConsensusParametersFragmentFragmentDoc}`;
     query getTransactionWithReceipts($transactionId: TransactionId!) {
   transaction(id: $transactionId) {
     ...transactionFragment
-    receipts {
-      ...receiptFragment
-    }
   }
 }
-    ${TransactionFragmentFragmentDoc}
-${ReceiptFragmentFragmentDoc}`;
+    ${TransactionFragmentFragmentDoc}`;
   var GetTransactionsDocument = lib_default2`
     query getTransactions($after: String, $before: String, $first: Int, $last: Int) {
   transactions(after: $after, before: $before, first: $first, last: $last) {
@@ -37712,6 +38638,20 @@ ${MessageCoinFragmentFragmentDoc}`;
   }
 }
     ${BalanceFragmentFragmentDoc}`;
+  var GetLatestGasPriceDocument = lib_default2`
+    query getLatestGasPrice {
+  latestGasPrice {
+    gasPrice
+  }
+}
+    `;
+  var EstimateGasPriceDocument = lib_default2`
+    query estimateGasPrice($blockHorizon: U32!) {
+  estimateGasPrice(blockHorizon: $blockHorizon) {
+    gasPrice
+  }
+}
+    `;
   var GetBalancesDocument = lib_default2`
     query getBalances($filter: BalanceFilterInput!, $after: String, $before: String, $first: Int, $last: Int) {
   balances(
@@ -37766,12 +38706,12 @@ ${MessageCoinFragmentFragmentDoc}`;
 }
     `;
   var DryRunDocument = lib_default2`
-    mutation dryRun($encodedTransaction: HexString!, $utxoValidation: Boolean) {
-  dryRun(tx: $encodedTransaction, utxoValidation: $utxoValidation) {
-    ...receiptFragment
+    mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean) {
+  dryRun(txs: $encodedTransactions, utxoValidation: $utxoValidation) {
+    ...dryRunTransactionExecutionStatusFragment
   }
 }
-    ${ReceiptFragmentFragmentDoc}`;
+    ${DryRunTransactionExecutionStatusFragmentFragmentDoc}`;
   var SubmitDocument = lib_default2`
     mutation submit($encodedTransaction: HexString!) {
   submit(tx: $encodedTransaction) {
@@ -37790,17 +38730,17 @@ ${MessageCoinFragmentFragmentDoc}`;
   var SubmitAndAwaitDocument = lib_default2`
     subscription submitAndAwait($encodedTransaction: HexString!) {
   submitAndAwait(tx: $encodedTransaction) {
-    ...transactionStatusFragment
+    ...transactionStatusSubscriptionFragment
   }
 }
-    ${TransactionStatusFragmentFragmentDoc}`;
+    ${TransactionStatusSubscriptionFragmentFragmentDoc}`;
   var StatusChangeDocument = lib_default2`
     subscription statusChange($transactionId: TransactionId!) {
   statusChange(id: $transactionId) {
-    ...transactionStatusFragment
+    ...transactionStatusSubscriptionFragment
   }
 }
-    ${TransactionStatusFragmentFragmentDoc}`;
+    ${TransactionStatusSubscriptionFragmentFragmentDoc}`;
   function getSdk(requester) {
     return {
       getVersion(variables, options) {
@@ -37854,6 +38794,12 @@ ${MessageCoinFragmentFragmentDoc}`;
       getBalance(variables, options) {
         return requester(GetBalanceDocument, variables, options);
       },
+      getLatestGasPrice(variables, options) {
+        return requester(GetLatestGasPriceDocument, variables, options);
+      },
+      estimateGasPrice(variables, options) {
+        return requester(EstimateGasPriceDocument, variables, options);
+      },
       getBalances(variables, options) {
         return requester(GetBalancesDocument, variables, options);
       },
@@ -38040,10 +38986,9 @@ ${MessageCoinFragmentFragmentDoc}`;
             txIndex: toNumber2(arrayify(value.txPointer).slice(8, 16))
           },
           witnessIndex: value.witnessIndex,
-          maturity: value.maturity ?? 0,
           predicateGasUsed: bn(value.predicateGasUsed),
-          predicateLength: predicate.length,
-          predicateDataLength: predicateData.length,
+          predicateLength: bn(predicate.length),
+          predicateDataLength: bn(predicateData.length),
           predicate: hexlify(predicate),
           predicateData: hexlify(predicateData)
         };
@@ -38074,8 +39019,8 @@ ${MessageCoinFragmentFragmentDoc}`;
           nonce: hexlify(value.nonce),
           witnessIndex: value.witnessIndex,
           predicateGasUsed: bn(value.predicateGasUsed),
-          predicateLength: predicate.length,
-          predicateDataLength: predicateData.length,
+          predicateLength: bn(predicate.length),
+          predicateDataLength: bn(predicateData.length),
           predicate: hexlify(predicate),
           predicateData: hexlify(predicateData),
           data: hexlify(data),
@@ -38235,8 +39180,8 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "CALL" /* Call */: {
         const callReceipt = {
           type: ReceiptType.Call,
-          from: hexOrZero(receipt.contract?.id),
-          to: hexOrZero(receipt?.to?.id),
+          from: hexOrZero(receipt.id || receipt.contractId),
+          to: hexOrZero(receipt?.to),
           amount: bn(receipt.amount),
           assetId: hexOrZero(receipt.assetId),
           gas: bn(receipt.gas),
@@ -38250,7 +39195,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "RETURN" /* Return */: {
         const returnReceipt = {
           type: ReceiptType.Return,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id || receipt.contractId),
           val: bn(receipt.val),
           pc: bn(receipt.pc),
           is: bn(receipt.is)
@@ -38260,7 +39205,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "RETURN_DATA" /* ReturnData */: {
         const returnDataReceipt = {
           type: ReceiptType.ReturnData,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id || receipt.contractId),
           ptr: bn(receipt.ptr),
           len: bn(receipt.len),
           digest: hexOrZero(receipt.digest),
@@ -38272,7 +39217,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "PANIC" /* Panic */: {
         const panicReceipt = {
           type: ReceiptType.Panic,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id),
           reason: bn(receipt.reason),
           pc: bn(receipt.pc),
           is: bn(receipt.is),
@@ -38283,7 +39228,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "REVERT" /* Revert */: {
         const revertReceipt = {
           type: ReceiptType.Revert,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id || receipt.contractId),
           val: bn(receipt.ra),
           pc: bn(receipt.pc),
           is: bn(receipt.is)
@@ -38293,7 +39238,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "LOG" /* Log */: {
         const logReceipt = {
           type: ReceiptType.Log,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id || receipt.contractId),
           val0: bn(receipt.ra),
           val1: bn(receipt.rb),
           val2: bn(receipt.rc),
@@ -38306,7 +39251,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "LOG_DATA" /* LogData */: {
         const logDataReceipt = {
           type: ReceiptType.LogData,
-          id: hexOrZero(receipt.contract?.id),
+          id: hexOrZero(receipt.id || receipt.contractId),
           val0: bn(receipt.ra),
           val1: bn(receipt.rb),
           ptr: bn(receipt.ptr),
@@ -38320,8 +39265,8 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "TRANSFER" /* Transfer */: {
         const transferReceipt = {
           type: ReceiptType.Transfer,
-          from: hexOrZero(receipt.contract?.id),
-          to: hexOrZero(receipt.toAddress || receipt?.to?.id),
+          from: hexOrZero(receipt.id || receipt.contractId),
+          to: hexOrZero(receipt.toAddress || receipt?.to),
           amount: bn(receipt.amount),
           assetId: hexOrZero(receipt.assetId),
           pc: bn(receipt.pc),
@@ -38332,8 +39277,8 @@ ${MessageCoinFragmentFragmentDoc}`;
       case "TRANSFER_OUT" /* TransferOut */: {
         const transferOutReceipt = {
           type: ReceiptType.TransferOut,
-          from: hexOrZero(receipt.contract?.id),
-          to: hexOrZero(receipt.toAddress || receipt.to?.id),
+          from: hexOrZero(receipt.id || receipt.contractId),
+          to: hexOrZero(receipt.toAddress || receipt.to),
           amount: bn(receipt.amount),
           assetId: hexOrZero(receipt.assetId),
           pc: bn(receipt.pc),
@@ -38376,7 +39321,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         return receiptMessageOut;
       }
       case "MINT" /* Mint */: {
-        const contractId = hexOrZero(receipt.contract?.id);
+        const contractId = hexOrZero(receipt.id || receipt.contractId);
         const subId = hexOrZero(receipt.subId);
         const assetId = ReceiptMintCoder.getAssetId(contractId, subId);
         const mintReceipt = {
@@ -38391,7 +39336,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         return mintReceipt;
       }
       case "BURN" /* Burn */: {
-        const contractId = hexOrZero(receipt.contract?.id);
+        const contractId = hexOrZero(receipt.id || receipt.contractId);
         const subId = hexOrZero(receipt.subId);
         const assetId = ReceiptBurnCoder.getAssetId(contractId, subId);
         const burnReceipt = {
@@ -38472,7 +39417,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   };
 
   // src/providers/utils/gas.ts
-  var calculatePriceWithFactor = (gas, gasPrice, priceFactor) => bn(Math.ceil(gas.mul(gasPrice).toNumber() / priceFactor.toNumber()));
   var getGasUsedFromReceipts = (receipts) => {
     const scriptResult = receipts.filter(
       (receipt) => receipt.type === ReceiptType.ScriptResult
@@ -38493,18 +39437,28 @@ ${MessageCoinFragmentFragmentDoc}`;
   }
   function gasUsedByInputs(inputs, txBytesSize, gasCosts) {
     const witnessCache = [];
-    const totalGas = inputs.reduce((total, input) => {
+    const chargeableInputs = inputs.filter((input) => {
+      const isCoinOrMessage = "owner" in input || "sender" in input;
+      if (isCoinOrMessage) {
+        if ("predicate" in input && input.predicate && input.predicate !== "0x") {
+          return true;
+        }
+        if (!witnessCache.includes(input.witnessIndex)) {
+          witnessCache.push(input.witnessIndex);
+          return true;
+        }
+      }
+      return false;
+    });
+    const vmInitializationCost = resolveGasDependentCosts(txBytesSize, gasCosts.vmInitialization);
+    const totalGas = chargeableInputs.reduce((total, input) => {
       if ("predicate" in input && input.predicate && input.predicate !== "0x") {
         return total.add(
-          resolveGasDependentCosts(txBytesSize, gasCosts.vmInitialization).add(resolveGasDependentCosts(arrayify(input.predicate).length, gasCosts.contractRoot)).add(bn(input.predicateGasUsed))
+          vmInitializationCost.add(resolveGasDependentCosts(arrayify(input.predicate).length, gasCosts.contractRoot)).add(bn(input.predicateGasUsed))
         );
       }
-      if ("witnessIndex" in input && !witnessCache.includes(input.witnessIndex)) {
-        witnessCache.push(input.witnessIndex);
-        return total.add(gasCosts.ecr1);
-      }
-      return total;
-    }, bn());
+      return total.add(gasCosts.ecr1);
+    }, bn(0));
     return totalGas;
   }
   function getMinGas(params) {
@@ -38516,12 +39470,20 @@ ${MessageCoinFragmentFragmentDoc}`;
     return minGas;
   }
   function getMaxGas(params) {
-    const { gasPerByte, witnessesLength, witnessLimit, minGas, gasLimit = bn(0) } = params;
+    const {
+      gasPerByte,
+      witnessesLength,
+      witnessLimit,
+      minGas,
+      gasLimit = bn(0),
+      maxGasPerTx
+    } = params;
     let remainingAllowedWitnessGas = bn(0);
     if (witnessLimit?.gt(0) && witnessLimit.gte(witnessesLength)) {
       remainingAllowedWitnessGas = bn(witnessLimit).sub(witnessesLength).mul(gasPerByte);
     }
-    return remainingAllowedWitnessGas.add(minGas).add(gasLimit);
+    const maxGas = remainingAllowedWitnessGas.add(minGas).add(gasLimit);
+    return maxGas.gte(maxGasPerTx) ? maxGasPerTx : maxGas;
   }
   function calculateMetadataGasForTxCreate({
     gasCosts,
@@ -38543,6 +39505,10 @@ ${MessageCoinFragmentFragmentDoc}`;
   }) {
     return resolveGasDependentCosts(txBytesSize, gasCosts.s256);
   }
+  var calculateGasFee = (params) => {
+    const { gas, gasPrice, priceFactor, tip } = params;
+    return gas.mul(gasPrice).div(priceFactor).add(tip);
+  };
 
   // src/providers/utils/json.ts
   function normalize2(object) {
@@ -38684,7 +39650,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   // src/providers/transaction-request/transaction-request.ts
   var BaseTransactionRequest = class {
     /** Gas price for transaction */
-    gasPrice;
+    tip;
     /** Block until which tx cannot be included */
     maturity;
     /** The maximum fee payable by this transaction using BASE_ASSET. */
@@ -38703,7 +39669,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param baseTransactionRequest - Optional object containing properties to initialize the transaction request.
      */
     constructor({
-      gasPrice,
+      tip,
       maturity,
       maxFee,
       witnessLimit,
@@ -38711,7 +39677,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       outputs,
       witnesses
     } = {}) {
-      this.gasPrice = bn(gasPrice);
+      this.tip = bn(tip);
       this.maturity = maturity ?? 0;
       this.witnessLimit = witnessLimit ? bn(witnessLimit) : void 0;
       this.maxFee = maxFee ? bn(maxFee) : void 0;
@@ -38722,9 +39688,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     static getPolicyMeta(req) {
       let policyTypes = 0;
       const policies = [];
-      if (req.gasPrice) {
-        policyTypes += PolicyType.GasPrice;
-        policies.push({ data: req.gasPrice, type: PolicyType.GasPrice });
+      if (req.tip) {
+        policyTypes += PolicyType.Tip;
+        policies.push({ data: req.tip, type: PolicyType.Tip });
       }
       if (req.witnessLimit) {
         policyTypes += PolicyType.WitnessLimit;
@@ -38908,13 +39874,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * assetId, if one it was not added yet.
      *
      * @param coin - Coin resource.
-     * @param predicate - Predicate bytes.
-     * @param predicateData - Predicate data bytes.
      */
-    addCoinInput(coin, predicate) {
+    addCoinInput(coin) {
       const { assetId, owner, amount } = coin;
       let witnessIndex;
-      if (predicate) {
+      if (coin.predicate) {
         witnessIndex = 0;
       } else {
         witnessIndex = this.getCoinInputWitnessIndexByOwner(owner);
@@ -38929,8 +39893,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         amount,
         assetId,
         txPointer: "0x00000000000000000000000000000000",
-        witnessIndex,
-        predicate: predicate?.bytes
+        witnessIndex
       };
       this.pushInput(input);
       this.addChangeOutput(owner, assetId);
@@ -38940,12 +39903,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * asset against the message
      *
      * @param message - Message resource.
-     * @param predicate - Predicate bytes.
      */
-    addMessageInput(message, predicate) {
+    addMessageInput(message) {
       const { recipient, sender, amount, assetId } = message;
       let witnessIndex;
-      if (predicate) {
+      if (message.predicate) {
         witnessIndex = 0;
       } else {
         witnessIndex = this.getCoinInputWitnessIndexByOwner(recipient);
@@ -38959,8 +39921,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         sender: sender.toB256(),
         recipient: recipient.toB256(),
         amount,
-        witnessIndex,
-        predicate: predicate?.bytes
+        witnessIndex
       };
       this.pushInput(input);
       this.addChangeOutput(recipient, assetId);
@@ -38991,32 +39952,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       resources.forEach((resource) => this.addResource(resource));
       return this;
     }
-    /**
-     * Adds multiple resources to the transaction by adding coin/message inputs and change
-     * outputs from the related assetIds.
-     *
-     * @param resources - The resources to add.
-     * @returns This transaction.
-     */
-    addPredicateResource(resource, predicate) {
-      if (isCoin(resource)) {
-        this.addCoinInput(resource, predicate);
-      } else {
-        this.addMessageInput(resource, predicate);
-      }
-      return this;
-    }
-    /**
-     * Adds multiple predicate coin/message inputs to the transaction and change outputs
-     * from the related assetIds.
-     *
-     * @param resources - The resources to add.
-     * @returns This transaction.
-     */
-    addPredicateResources(resources, predicate) {
-      resources.forEach((resource) => this.addPredicateResource(resource, predicate));
-      return this;
-    }
     /**
      * Adds a coin output to the transaction.
      *
@@ -39096,7 +40031,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     }
     calculateMaxGas(chainInfo, minGas) {
       const { consensusParameters } = chainInfo;
-      const { gasPerByte } = consensusParameters;
+      const { gasPerByte, maxGasPerTx } = consensusParameters;
       const witnessesLength = this.toTransaction().witnesses.reduce(
         (acc, wit) => acc + wit.dataLength,
         0
@@ -39105,7 +40040,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         gasPerByte,
         minGas,
         witnessesLength,
-        witnessLimit: this.witnessLimit
+        witnessLimit: this.witnessLimit,
+        maxGasPerTx
       });
     }
     /**
@@ -39124,17 +40060,20 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       });
       const updateAssetInput = (assetId, quantity) => {
         const assetInput = findAssetInput(assetId);
+        let usedQuantity = quantity;
+        if (assetId === baseAssetId) {
+          usedQuantity = bn("1000000000000000000");
+        }
         if (assetInput && "assetId" in assetInput) {
           assetInput.id = hexlify(randomBytes22(UTXO_ID_LEN));
-          assetInput.amount = quantity;
+          assetInput.amount = usedQuantity;
         } else {
           this.addResources([
             {
               id: hexlify(randomBytes22(UTXO_ID_LEN)),
-              amount: quantity,
+              amount: usedQuantity,
               assetId,
               owner: resourcesOwner || Address.fromRandom(),
-              maturity: 0,
               blockCreated: bn(1),
               txCreatedIdx: bn(1)
             }
@@ -39166,7 +40105,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     toJSON() {
       return normalizeJSON(this);
     }
-    updatePredicateInputs(inputs) {
+    updatePredicateGasUsed(inputs) {
       this.inputs.forEach((i) => {
         let correspondingInput;
         switch (i.type) {
@@ -39188,6 +40127,15 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       });
     }
+    shiftPredicateData() {
+      this.inputs.forEach((input) => {
+        if ("predicateData" in input && "padPredicateData" in input && typeof input.padPredicateData === "function") {
+          input.predicateData = input.padPredicateData(
+            BaseTransactionRequest.getPolicyMeta(this).policies.length
+          );
+        }
+      });
+    }
   };
 
   // src/providers/transaction-request/hash-transaction.ts
@@ -39316,9 +40264,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       return {
         type: TransactionType.Create,
         ...baseTransaction,
-        bytecodeLength: baseTransaction.witnesses[bytecodeWitnessIndex].dataLength / 4,
         bytecodeWitnessIndex,
-        storageSlotsCount: storageSlots.length,
+        storageSlotsCount: bn(storageSlots.length),
         salt: this.salt ? hexlify(this.salt) : ZeroBytes32,
         storageSlots
       };
@@ -39432,8 +40379,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         type: TransactionType.Script,
         scriptGasLimit: this.gasLimit,
         ...super.getBaseTransaction(),
-        scriptLength: script.length,
-        scriptDataLength: scriptData.length,
+        scriptLength: bn(script.length),
+        scriptDataLength: bn(scriptData.length),
         receiptsRoot: ZeroBytes32,
         script: hexlify(script),
         scriptData: hexlify(scriptData)
@@ -39497,7 +40444,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     }
     calculateMaxGas(chainInfo, minGas) {
       const { consensusParameters } = chainInfo;
-      const { gasPerByte } = consensusParameters;
+      const { gasPerByte, maxGasPerTx } = consensusParameters;
       const witnessesLength = this.toTransaction().witnesses.reduce(
         (acc, wit) => acc + wit.dataLength,
         0
@@ -39507,7 +40454,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         minGas,
         witnessesLength,
         witnessLimit: this.witnessLimit,
-        gasLimit: this.gasLimit
+        gasLimit: this.gasLimit,
+        maxGasPerTx
       });
     }
     /**
@@ -39580,13 +40528,29 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
     }
   };
+  var cacheTxInputsFromOwner = (inputs, owner) => inputs.reduce(
+    (acc, input) => {
+      if (input.type === InputType.Coin && input.owner === owner) {
+        acc.utxos.push(input.id);
+      }
+      if (input.type === InputType.Message && input.recipient === owner) {
+        acc.messages.push(input.nonce);
+      }
+      return acc;
+    },
+    {
+      utxos: [],
+      messages: []
+    }
+  );
 
   // src/providers/transaction-summary/calculate-transaction-fee.ts
   var calculateTransactionFee = (params) => {
     const {
-      gasUsed,
+      gasPrice,
       rawPayload,
-      consensusParameters: { gasCosts, feeParams }
+      tip,
+      consensusParameters: { gasCosts, feeParams, maxGasPerTx }
     } = params;
     const gasPerByte = bn(feeParams.gasPerByte);
     const gasPriceFactor = bn(feeParams.gasPriceFactor);
@@ -39596,8 +40560,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       return {
         fee: bn(0),
         minFee: bn(0),
-        maxFee: bn(0),
-        feeFromGasUsed: bn(0)
+        maxFee: bn(0)
       };
     }
     const { type: type3, witnesses, inputs, policies } = transaction;
@@ -39629,7 +40592,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       metadataGas,
       txBytesSize: transactionBytes.length
     });
-    const gasPrice = bn(policies.find((policy) => policy.type === PolicyType.GasPrice)?.data);
     const witnessLimit = policies.find((policy) => policy.type === PolicyType.WitnessLimit)?.data;
     const witnessesLength = witnesses.reduce((acc, wit) => acc + wit.dataLength, 0);
     const maxGas = getMaxGas({
@@ -39637,17 +40599,25 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       minGas,
       witnessesLength,
       gasLimit,
-      witnessLimit
+      witnessLimit,
+      maxGasPerTx
+    });
+    const minFee = calculateGasFee({
+      gasPrice,
+      gas: minGas,
+      priceFactor: gasPriceFactor,
+      tip
+    });
+    const maxFee = calculateGasFee({
+      gasPrice,
+      gas: maxGas,
+      priceFactor: gasPriceFactor,
+      tip
     });
-    const feeFromGasUsed = calculatePriceWithFactor(gasUsed, gasPrice, gasPriceFactor);
-    const minFee = calculatePriceWithFactor(minGas, gasPrice, gasPriceFactor);
-    const maxFee = calculatePriceWithFactor(maxGas, gasPrice, gasPriceFactor);
-    const fee = minFee.add(feeFromGasUsed);
     return {
-      fee,
       minFee,
       maxFee,
-      feeFromGasUsed
+      fee: maxFee
     };
   };
 
@@ -40248,7 +41218,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       gqlTransactionStatus,
       abiMap = {},
       maxInputs,
-      gasCosts
+      gasCosts,
+      maxGasPerTx,
+      gasPrice
     } = params;
     const gasUsed = getGasUsedFromReceipts(receipts);
     const rawPayload = hexlify(transactionBytes);
@@ -40262,11 +41234,14 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       maxInputs
     });
     const typeName = getTransactionTypeName(transaction.type);
+    const tip = bn(transaction.policies?.find((policy) => policy.type === PolicyType.Tip)?.data);
     const { fee } = calculateTransactionFee({
-      gasUsed,
+      gasPrice,
       rawPayload,
+      tip,
       consensusParameters: {
         gasCosts,
+        maxGasPerTx,
         feeParams: {
           gasPerByte,
           gasPriceFactor
@@ -40318,7 +41293,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 */
@@ -40348,7 +41323,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;
     }
@@ -40402,8 +41377,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       const decodedTransaction = this.decodeTransaction(
         transaction
       );
-      const receipts = transaction.receipts?.map(processGqlReceipt) || [];
-      const { gasPerByte, gasPriceFactor, gasCosts } = this.provider.getGasConfig();
+      let txReceipts = [];
+      if (transaction?.status && "receipts" in transaction.status) {
+        txReceipts = transaction.status.receipts;
+      }
+      const receipts = txReceipts.map(processGqlReceipt) || [];
+      const { gasPerByte, gasPriceFactor, gasCosts, maxGasPerTx } = this.provider.getGasConfig();
+      const gasPrice = await this.provider.getLatestGasPrice();
       const maxInputs = this.provider.getChain().consensusParameters.maxInputs;
       const transactionSummary = assembleTransactionSummary({
         id: this.id,
@@ -40415,7 +41395,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         gasPriceFactor,
         abiMap: contractsAbiMap,
         maxInputs,
-        gasCosts
+        gasCosts,
+        maxGasPerTx,
+        gasPrice
       });
       return transactionSummary;
     }
@@ -40564,7 +41546,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       gasCosts,
       latestBlock: {
         id: latestBlock.id,
-        height: bn(latestBlock.header.height),
+        height: bn(latestBlock.height),
         time: latestBlock.header.time,
         transactions: latestBlock.transactions.map((i) => ({
           id: i.id
@@ -40658,10 +41640,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * Returns some helpful parameters related to gas fees.
      */
     getGasConfig() {
-      const { minGasPrice } = this.getNode();
       const { maxGasPerTx, maxGasPerPredicate, gasPriceFactor, gasPerByte, gasCosts } = this.getChain().consensusParameters;
       return {
-        minGasPrice,
         maxGasPerTx,
         maxGasPerPredicate,
         gasPriceFactor,
@@ -40737,6 +41717,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.
      *
@@ -40744,7 +41739,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     async getBlockNumber() {
       const { chain } = await this.operations.getChain();
-      return bn(chain.latestBlock.header.height, 10);
+      return bn(chain.latestBlock.height, 10);
     }
     /**
      * Returns the chain information.
@@ -40756,11 +41751,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       const processedNodeInfo = {
         maxDepth: bn(nodeInfo.maxDepth),
         maxTx: bn(nodeInfo.maxTx),
-        minGasPrice: bn(nodeInfo.minGasPrice),
         nodeVersion: nodeInfo.nodeVersion,
         utxoValidation: nodeInfo.utxoValidation,
-        vmBacktrace: nodeInfo.vmBacktrace,
-        peers: nodeInfo.peers
+        vmBacktrace: nodeInfo.vmBacktrace
       };
       _Provider.nodeInfoCache[this.url] = processedNodeInfo;
       return processedNodeInfo;
@@ -40832,14 +41825,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.
@@ -40857,14 +41850,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         return this.estimateTxDependencies(transactionRequest);
       }
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
-      const { dryRun: gqlReceipts } = await this.operations.dryRun({
-        encodedTransaction,
+      const { dryRun: dryRunStatuses } = await this.operations.dryRun({
+        encodedTransactions: encodedTransaction,
         utxoValidation: utxoValidation || false
       });
-      const receipts = gqlReceipts.map(processGqlReceipt);
-      return {
-        receipts
-      };
+      const [{ receipts: rawReceipts, status }] = dryRunStatuses;
+      const receipts = rawReceipts.map(processGqlReceipt);
+      return { receipts, dryrunStatus: status };
     }
     /**
      * Verifies whether enough gas is available to complete transaction.
@@ -40903,9 +41895,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * If there are missing variable outputs,
      * `addVariableOutputs` is called on the transaction.
      *
-     * @privateRemarks
-     * TODO: Investigate support for missing contract IDs
-     * TODO: Add support for missing output messages
      *
      * @param transactionRequest - The transaction request object.
      * @returns A promise.
@@ -40918,16 +41907,19 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           missingContractIds: []
         };
       }
-      await this.estimatePredicates(transactionRequest);
       let receipts = [];
       const missingContractIds = [];
       let outputVariables = 0;
+      let dryrunStatus;
       for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-        const { dryRun: gqlReceipts } = await this.operations.dryRun({
-          encodedTransaction: hexlify(transactionRequest.toTransactionBytes()),
+        const {
+          dryRun: [{ receipts: rawReceipts, status }]
+        } = await this.operations.dryRun({
+          encodedTransactions: [hexlify(transactionRequest.toTransactionBytes())],
           utxoValidation: false
         });
-        receipts = gqlReceipts.map(processGqlReceipt);
+        receipts = rawReceipts.map(processGqlReceipt);
+        dryrunStatus = status;
         const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
         const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
         if (hasMissingOutputs) {
@@ -40937,6 +41929,10 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
             transactionRequest.addContractInputAndOutput(Address.fromString(contractId));
             missingContractIds.push(contractId);
           });
+          const { maxFee } = await this.estimateTxGasAndFee({
+            transactionRequest
+          });
+          transactionRequest.maxFee = maxFee;
         } else {
           break;
         }
@@ -40944,37 +41940,136 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       return {
         receipts,
         outputVariables,
-        missingContractIds
+        missingContractIds,
+        dryrunStatus
       };
     }
+    /**
+     * Dry runs multiple transactions and checks for missing dependencies in batches.
+     *
+     * Transactions are dry run in batches. After each dry run, transactions requiring
+     * further modifications are identified. The method iteratively updates these transactions
+     * and performs subsequent dry runs until all dependencies for each transaction are satisfied.
+     *
+     * @param transactionRequests - Array of transaction request objects.
+     * @returns A promise that resolves to an array of results for each transaction.
+     */
+    async estimateMultipleTxDependencies(transactionRequests) {
+      const results = transactionRequests.map(() => ({
+        receipts: [],
+        outputVariables: 0,
+        missingContractIds: [],
+        dryrunStatus: void 0
+      }));
+      const allRequests = clone_default(transactionRequests);
+      const serializedTransactionsMap = /* @__PURE__ */ new Map();
+      allRequests.forEach((req, index) => {
+        if (req.type === TransactionType.Script) {
+          serializedTransactionsMap.set(index, hexlify(req.toTransactionBytes()));
+        }
+      });
+      let transactionsToProcess = Array.from(serializedTransactionsMap.keys());
+      let attempt = 0;
+      while (transactionsToProcess.length > 0 && attempt < MAX_RETRIES) {
+        const encodedTransactions = transactionsToProcess.map(
+          (index) => serializedTransactionsMap.get(index)
+        );
+        const dryRunResults = await this.operations.dryRun({
+          encodedTransactions,
+          utxoValidation: false
+        });
+        const nextRoundTransactions = [];
+        for (let i = 0; i < dryRunResults.dryRun.length; i++) {
+          const requestIdx = transactionsToProcess[i];
+          const { receipts: rawReceipts, status } = dryRunResults.dryRun[i];
+          const result = results[requestIdx];
+          result.receipts = rawReceipts.map(processGqlReceipt);
+          result.dryrunStatus = status;
+          const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(
+            result.receipts
+          );
+          const hasMissingOutputs = missingOutputVariables.length > 0 || missingOutputContractIds.length > 0;
+          const request = allRequests[requestIdx];
+          if (hasMissingOutputs && request?.type === TransactionType.Script) {
+            result.outputVariables += missingOutputVariables.length;
+            request.addVariableOutputs(missingOutputVariables.length);
+            missingOutputContractIds.forEach(({ contractId }) => {
+              request.addContractInputAndOutput(Address.fromString(contractId));
+              result.missingContractIds.push(contractId);
+            });
+            const { maxFee } = await this.estimateTxGasAndFee({
+              transactionRequest: request
+            });
+            request.maxFee = maxFee;
+            serializedTransactionsMap.set(requestIdx, hexlify(request.toTransactionBytes()));
+            nextRoundTransactions.push(requestIdx);
+          }
+        }
+        transactionsToProcess = nextRoundTransactions;
+        attempt += 1;
+      }
+      return results;
+    }
+    async dryRunMultipleTransactions(transactionRequests, { utxoValidation, estimateTxDependencies = true } = {}) {
+      if (estimateTxDependencies) {
+        return this.estimateMultipleTxDependencies(transactionRequests);
+      }
+      const encodedTransactions = transactionRequests.map((tx) => hexlify(tx.toTransactionBytes()));
+      const { dryRun: dryRunStatuses } = await this.operations.dryRun({
+        encodedTransactions,
+        utxoValidation: utxoValidation || false
+      });
+      const results = dryRunStatuses.map(({ receipts: rawReceipts, status }) => {
+        const receipts = rawReceipts.map(processGqlReceipt);
+        return { receipts, dryrunStatus: status };
+      });
+      return results;
+    }
     /**
      * Estimates the transaction gas and fee based on the provided transaction request.
      * @param transactionRequest - The transaction request object.
      * @returns An object containing the estimated minimum gas, minimum fee, maximum gas, and maximum fee.
      */
-    estimateTxGasAndFee(params) {
+    async estimateTxGasAndFee(params) {
       const { transactionRequest } = params;
-      const { gasPriceFactor, minGasPrice, maxGasPerTx } = this.getGasConfig();
+      let { gasPrice } = params;
       const chainInfo = this.getChain();
-      const gasPrice = transactionRequest.gasPrice.eq(0) ? minGasPrice : transactionRequest.gasPrice;
-      transactionRequest.gasPrice = gasPrice;
+      const { gasPriceFactor, maxGasPerTx } = this.getGasConfig();
       const minGas = transactionRequest.calculateMinGas(chainInfo);
-      const minFee = calculatePriceWithFactor(minGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
+      if (!gasPrice) {
+        gasPrice = await this.estimateGasPrice(10);
+      }
+      const minFee = calculateGasFee({
+        gasPrice: bn(gasPrice),
+        gas: minGas,
+        priceFactor: gasPriceFactor,
+        tip: transactionRequest.tip
+      }).add(1);
+      let gasLimit = bn(0);
       if (transactionRequest.type === TransactionType.Script) {
+        gasLimit = transactionRequest.gasLimit;
         if (transactionRequest.gasLimit.eq(0)) {
           transactionRequest.gasLimit = minGas;
           transactionRequest.gasLimit = maxGasPerTx.sub(
             transactionRequest.calculateMaxGas(chainInfo, minGas)
           );
+          gasLimit = transactionRequest.gasLimit;
         }
       }
       const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
-      const maxFee = calculatePriceWithFactor(maxGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
+      const maxFee = calculateGasFee({
+        gasPrice: bn(gasPrice),
+        gas: maxGas,
+        priceFactor: gasPriceFactor,
+        tip: transactionRequest.tip
+      }).add(1);
       return {
         minGas,
         minFee,
         maxGas,
-        maxFee
+        maxFee,
+        gasPrice,
+        gasLimit
       };
     }
     /**
@@ -40992,15 +42087,17 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       if (estimateTxDependencies) {
         return this.estimateTxDependencies(transactionRequest);
       }
-      const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
-      const { dryRun: gqlReceipts } = await this.operations.dryRun({
-        encodedTransaction,
+      const encodedTransactions = [hexlify(transactionRequest.toTransactionBytes())];
+      const { dryRun: dryRunStatuses } = await this.operations.dryRun({
+        encodedTransactions,
         utxoValidation: true
       });
-      const receipts = gqlReceipts.map(processGqlReceipt);
-      return {
-        receipts
-      };
+      const callResult = dryRunStatuses.map((dryRunStatus) => {
+        const { id, receipts, status } = dryRunStatus;
+        const processedReceipts = receipts.map(processGqlReceipt);
+        return { id, receipts: processedReceipts, status };
+      });
+      return { receipts: callResult[0].receipts };
     }
     /**
      * Returns a transaction cost to enable user
@@ -41017,78 +42114,80 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param tolerance - The tolerance to add on top of the gasUsed.
      * @returns A promise that resolves to the transaction cost object.
      */
-    async getTransactionCost(transactionRequestLike, forwardingQuantities = [], {
-      estimateTxDependencies = true,
-      estimatePredicates = true,
-      resourcesOwner,
-      signatureCallback
-    } = {}) {
+    async getTransactionCost(transactionRequestLike, { resourcesOwner, signatureCallback, quantitiesToContract = [] } = {}) {
       const txRequestClone = clone_default(transactionRequestify(transactionRequestLike));
-      const { minGasPrice } = this.getGasConfig();
-      const setGasPrice = max(txRequestClone.gasPrice, minGasPrice);
       const isScriptTransaction = txRequestClone.type === TransactionType.Script;
       const baseAssetId = this.getBaseAssetId();
       const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
-      const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
+      const allQuantities = mergeQuantities(coinOutputsQuantities, quantitiesToContract);
       txRequestClone.fundWithFakeUtxos(allQuantities, baseAssetId, resourcesOwner?.address);
+      txRequestClone.maxFee = bn(0);
       if (isScriptTransaction) {
         txRequestClone.gasLimit = bn(0);
       }
-      if (estimatePredicates) {
-        if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
-          resourcesOwner.populateTransactionPredicateData(txRequestClone);
-        }
-        await this.estimatePredicates(txRequestClone);
+      if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
+        resourcesOwner.populateTransactionPredicateData(txRequestClone);
       }
+      const signedRequest = clone_default(txRequestClone);
+      let addedSignatures = 0;
       if (signatureCallback && isScriptTransaction) {
-        await signatureCallback(txRequestClone);
+        const lengthBefore = signedRequest.witnesses.length;
+        await signatureCallback(signedRequest);
+        addedSignatures = signedRequest.witnesses.length - lengthBefore;
       }
-      let { maxFee, maxGas, minFee, minGas } = this.estimateTxGasAndFee({
-        transactionRequest: txRequestClone
+      await this.estimatePredicates(signedRequest);
+      let { maxFee, maxGas, minFee, minGas, gasPrice, gasLimit } = await this.estimateTxGasAndFee({
+        transactionRequest: signedRequest
       });
       let receipts = [];
       let missingContractIds = [];
       let outputVariables = 0;
       let gasUsed = bn(0);
-      if (isScriptTransaction && estimateTxDependencies) {
-        txRequestClone.gasPrice = bn(0);
+      txRequestClone.updatePredicateGasUsed(signedRequest.inputs);
+      txRequestClone.maxFee = maxFee;
+      if (isScriptTransaction) {
+        txRequestClone.gasLimit = gasLimit;
+        if (signatureCallback) {
+          await signatureCallback(txRequestClone);
+        }
         const result = await this.estimateTxDependencies(txRequestClone);
         receipts = result.receipts;
         outputVariables = result.outputVariables;
         missingContractIds = result.missingContractIds;
         gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : gasUsed;
         txRequestClone.gasLimit = gasUsed;
-        txRequestClone.gasPrice = setGasPrice;
-        ({ maxFee, maxGas, minFee, minGas } = this.estimateTxGasAndFee({
-          transactionRequest: txRequestClone
+        ({ maxFee, maxGas, minFee, minGas, gasPrice } = await this.estimateTxGasAndFee({
+          transactionRequest: txRequestClone,
+          gasPrice
         }));
       }
       return {
         requiredQuantities: allQuantities,
         receipts,
         gasUsed,
-        minGasPrice,
-        gasPrice: setGasPrice,
+        gasPrice,
         minGas,
         maxGas,
         minFee,
         maxFee,
-        estimatedInputs: txRequestClone.inputs,
         outputVariables,
-        missingContractIds
+        missingContractIds,
+        addedSignatures,
+        estimatedPredicates: txRequestClone.inputs
       };
     }
-    async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
+    async getResourcesForTransaction(owner, transactionRequestLike, quantitiesToContract = []) {
       const ownerAddress = Address.fromAddressOrString(owner);
       const transactionRequest = transactionRequestify(clone_default(transactionRequestLike));
-      const transactionCost = await this.getTransactionCost(transactionRequest, forwardingQuantities);
+      const transactionCost = await this.getTransactionCost(transactionRequest, {
+        quantitiesToContract
+      });
       transactionRequest.addResources(
         await this.getResourcesToSpend(ownerAddress, transactionCost.requiredQuantities)
       );
-      const { requiredQuantities, ...txCost } = await this.getTransactionCost(
-        transactionRequest,
-        forwardingQuantities
-      );
+      const { requiredQuantities, ...txCost } = await this.getTransactionCost(transactionRequest, {
+        quantitiesToContract
+      });
       const resources = await this.getResourcesToSpend(ownerAddress, requiredQuantities);
       return {
         resources,
@@ -41112,7 +42211,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         assetId: coin.assetId,
         amount: bn(coin.amount),
         owner: Address.fromAddressOrString(coin.owner),
-        maturity: bn(coin.maturity).toNumber(),
         blockCreated: bn(coin.blockCreated),
         txCreatedIdx: bn(coin.txCreatedIdx)
       }));
@@ -41164,7 +42262,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
               amount: bn(coin.amount),
               assetId: coin.assetId,
               owner: Address.fromAddressOrString(coin.owner),
-              maturity: bn(coin.maturity).toNumber(),
               blockCreated: bn(coin.blockCreated),
               txCreatedIdx: bn(coin.txCreatedIdx)
             };
@@ -41197,7 +42294,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
       return {
         id: block2.id,
-        height: bn(block2.header.height),
+        height: bn(block2.height),
         time: block2.header.time,
         transactionIds: block2.transactions.map((tx) => tx.id)
       };
@@ -41212,7 +42309,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       const { blocks: fetchedData } = await this.operations.getBlocks(params);
       const blocks = fetchedData.edges.map(({ node: block2 }) => ({
         id: block2.id,
-        height: bn(block2.header.height),
+        height: bn(block2.height),
         time: block2.header.time,
         transactionIds: block2.transactions.map((tx) => tx.id)
       }));
@@ -41239,7 +42336,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
       return {
         id: block2.id,
-        height: bn(block2.header.height, 10),
+        height: bn(block2.height, 10),
         time: block2.header.time,
         transactionIds: block2.transactions.map((tx) => tx.id),
         transactions: block2.transactions.map(
@@ -41419,8 +42516,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           prevRoot: messageBlockHeader.prevRoot,
           time: messageBlockHeader.time,
           applicationHash: messageBlockHeader.applicationHash,
-          messageReceiptRoot: messageBlockHeader.messageReceiptRoot,
-          messageReceiptCount: bn(messageBlockHeader.messageReceiptCount)
+          messageReceiptCount: bn(messageBlockHeader.messageReceiptCount),
+          messageOutboxRoot: messageBlockHeader.messageOutboxRoot,
+          consensusParametersVersion: messageBlockHeader.consensusParametersVersion,
+          eventInboxRoot: messageBlockHeader.eventInboxRoot,
+          stateTransitionBytecodeVersion: messageBlockHeader.stateTransitionBytecodeVersion
         },
         commitBlockHeader: {
           id: commitBlockHeader.id,
@@ -41431,8 +42531,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           prevRoot: commitBlockHeader.prevRoot,
           time: commitBlockHeader.time,
           applicationHash: commitBlockHeader.applicationHash,
-          messageReceiptRoot: commitBlockHeader.messageReceiptRoot,
-          messageReceiptCount: bn(commitBlockHeader.messageReceiptCount)
+          messageReceiptCount: bn(commitBlockHeader.messageReceiptCount),
+          messageOutboxRoot: commitBlockHeader.messageOutboxRoot,
+          consensusParametersVersion: commitBlockHeader.consensusParametersVersion,
+          eventInboxRoot: commitBlockHeader.eventInboxRoot,
+          stateTransitionBytecodeVersion: commitBlockHeader.stateTransitionBytecodeVersion
         },
         sender: Address.fromAddressOrString(sender),
         recipient: Address.fromAddressOrString(recipient),
@@ -41441,6 +42544,16 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         data
       };
     }
+    async getLatestGasPrice() {
+      const { latestGasPrice } = await this.operations.getLatestGasPrice();
+      return bn(latestGasPrice.gasPrice);
+    }
+    async estimateGasPrice(blockHorizon) {
+      const { estimateGasPrice } = await this.operations.estimateGasPrice({
+        blockHorizon: String(blockHorizon)
+      });
+      return bn(estimateGasPrice.gasPrice);
+    }
     /**
      * Returns Message Proof for given transaction id and the message id from MessageOut receipt.
      *
@@ -41467,7 +42580,7 @@ ${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);
     }
   };
   var Provider = _Provider;
@@ -41501,10 +42614,15 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       arrayify(gqlTransaction.rawPayload),
       0
     );
-    const receipts = gqlTransaction.receipts?.map(processGqlReceipt) || [];
+    let txReceipts = [];
+    if (gqlTransaction?.status && "receipts" in gqlTransaction.status) {
+      txReceipts = gqlTransaction.status.receipts;
+    }
+    const receipts = txReceipts.map(processGqlReceipt);
     const {
-      consensusParameters: { gasPerByte, gasPriceFactor, maxInputs, gasCosts }
+      consensusParameters: { gasPerByte, gasPriceFactor, maxInputs, gasCosts, maxGasPerTx }
     } = provider.getChain();
+    const gasPrice = await provider.getLatestGasPrice();
     const transactionInfo = assembleTransactionSummary({
       id: gqlTransaction.id,
       receipts,
@@ -41515,7 +42633,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       gasPriceFactor: bn(gasPriceFactor),
       abiMap,
       maxInputs,
-      gasCosts
+      gasCosts,
+      maxGasPerTx,
+      gasPrice
     });
     return {
       gqlTransaction,
@@ -41525,10 +42645,11 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   async function getTransactionSummaryFromRequest(params) {
     const { provider, transactionRequest, abiMap } = params;
     const { receipts } = await provider.call(transactionRequest);
-    const { gasPerByte, gasPriceFactor, gasCosts } = provider.getGasConfig();
+    const { gasPerByte, gasPriceFactor, gasCosts, maxGasPerTx } = provider.getGasConfig();
     const maxInputs = provider.getChain().consensusParameters.maxInputs;
     const transaction = transactionRequest.toTransaction();
     const transactionBytes = transactionRequest.toTransactionBytes();
+    const gasPrice = await provider.getLatestGasPrice();
     const transactionSummary = assembleTransactionSummary({
       receipts,
       transaction,
@@ -41537,7 +42658,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       gasPerByte,
       gasPriceFactor,
       maxInputs,
-      gasCosts
+      gasCosts,
+      maxGasPerTx,
+      gasPrice
     });
     return transactionSummary;
   }
@@ -41546,13 +42669,18 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     const { transactionsByOwner } = await provider.operations.getTransactionsByOwner(filters);
     const { edges, pageInfo } = transactionsByOwner;
     const {
-      consensusParameters: { gasPerByte, gasPriceFactor, maxInputs, gasCosts }
+      consensusParameters: { gasPerByte, gasPriceFactor, maxInputs, gasCosts, maxGasPerTx }
     } = provider.getChain();
+    const gasPrice = await provider.getLatestGasPrice();
     const transactions = edges.map((edge) => {
       const { node: gqlTransaction } = edge;
-      const { id, rawPayload, receipts: gqlReceipts, status } = gqlTransaction;
+      const { id, rawPayload, status } = gqlTransaction;
       const [decodedTransaction] = new TransactionCoder().decode(arrayify(rawPayload), 0);
-      const receipts = gqlReceipts?.map(processGqlReceipt) || [];
+      let txReceipts = [];
+      if (gqlTransaction?.status && "receipts" in gqlTransaction.status) {
+        txReceipts = gqlTransaction.status.receipts;
+      }
+      const receipts = txReceipts.map(processGqlReceipt);
       const transactionSummary = assembleTransactionSummary({
         id,
         receipts,
@@ -41563,7 +42691,9 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         gasPerByte,
         gasPriceFactor,
         maxInputs,
-        gasCosts
+        gasCosts,
+        maxGasPerTx,
+        gasPrice
       });
       const output3 = {
         gqlTransaction,
@@ -41893,38 +43023,31 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param fee - The estimated transaction fee.
      * @returns A promise that resolves when the resources are added to the transaction.
      */
-    async fund(request, coinQuantities, fee) {
+    async fund(request, params) {
+      const { addedSignatures, estimatedPredicates, maxFee: fee, requiredQuantities } = params;
       const baseAssetId = this.provider.getBaseAssetId();
-      const updatedQuantities = addAmountToAsset({
+      const txRequest = request;
+      const requiredQuantitiesWithFee = addAmountToCoinQuantities({
         amount: bn(fee),
         assetId: baseAssetId,
-        coinQuantities
+        coinQuantities: requiredQuantities
       });
       const quantitiesDict = {};
-      updatedQuantities.forEach(({ amount, assetId }) => {
+      requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
         quantitiesDict[assetId] = {
           required: amount,
           owned: bn(0)
         };
       });
-      const cachedUtxos = [];
-      const cachedMessages = [];
-      const owner = this.address.toB256();
-      request.inputs.forEach((input) => {
+      txRequest.inputs.forEach((input) => {
         const isResource = "amount" in input;
-        if (isResource) {
-          const isCoin2 = "owner" in input;
-          if (isCoin2) {
-            const assetId = String(input.assetId);
-            if (input.owner === owner && quantitiesDict[assetId]) {
-              const amount = bn(input.amount);
-              quantitiesDict[assetId].owned = quantitiesDict[assetId].owned.add(amount);
-              cachedUtxos.push(input.id);
-            }
-          } else if (input.recipient === owner && input.amount && quantitiesDict[baseAssetId]) {
-            quantitiesDict[baseAssetId].owned = quantitiesDict[baseAssetId].owned.add(input.amount);
-            cachedMessages.push(input.nonce);
-          }
+        if (!isResource) {
+          return;
+        }
+        const isCoin2 = "owner" in input;
+        const assetId = isCoin2 ? String(input.assetId) : baseAssetId;
+        if (quantitiesDict[assetId]) {
+          quantitiesDict[assetId].owned = quantitiesDict[assetId].owned.add(input.amount);
         }
       });
       const missingQuantities = [];
@@ -41938,12 +43061,21 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       });
       const needsToBeFunded = missingQuantities.length;
       if (needsToBeFunded) {
-        const resources = await this.getResourcesToSpend(missingQuantities, {
-          messages: cachedMessages,
-          utxos: cachedUtxos
-        });
-        request.addResources(resources);
-      }
+        const excludedIds = cacheTxInputsFromOwner(txRequest.inputs, this.address.toB256());
+        const resources = await this.getResourcesToSpend(missingQuantities, excludedIds);
+        txRequest.addResources(resources);
+      }
+      txRequest.shiftPredicateData();
+      txRequest.updatePredicateGasUsed(estimatedPredicates);
+      const requestToReestimate = clone_default(txRequest);
+      if (addedSignatures) {
+        Array.from({ length: addedSignatures }).forEach(() => requestToReestimate.addEmptyWitness());
+      }
+      const { maxFee } = await this.provider.estimateTxGasAndFee({
+        transactionRequest: requestToReestimate
+      });
+      txRequest.maxFee = maxFee;
+      return txRequest;
     }
     /**
      * A helper that creates a transfer transaction request and returns it.
@@ -41951,29 +43083,25 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param destination - The address of the destination.
      * @param amount - The amount of coins to transfer.
      * @param assetId - The asset ID of the coins to transfer.
-     * @param txParams - The transaction parameters (gasLimit, gasPrice, maturity).
+     * @param txParams - The transaction parameters (gasLimit, tip, maturity, maxFee, witnessLimit).
      * @returns A promise that resolves to the prepared transaction request.
      */
     async createTransfer(destination, amount, assetId, txParams = {}) {
-      const { minGasPrice } = this.provider.getGasConfig();
+      const request = new ScriptTransactionRequest(txParams);
       const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
-      const params = { gasPrice: minGasPrice, ...txParams };
-      const request = new ScriptTransactionRequest(params);
       request.addCoinOutput(Address.fromAddressOrString(destination), amount, assetIdToTransfer);
-      const { maxFee, requiredQuantities, gasUsed, estimatedInputs } = await this.provider.getTransactionCost(request, [], {
+      const txCost = await this.provider.getTransactionCost(request, {
         estimateTxDependencies: true,
         resourcesOwner: this
       });
-      request.gasPrice = bn(txParams.gasPrice ?? minGasPrice);
-      request.gasLimit = bn(txParams.gasLimit ?? gasUsed);
-      this.validateGas({
-        gasUsed,
-        gasPrice: request.gasPrice,
-        gasLimit: request.gasLimit,
-        minGasPrice
+      this.validateGasLimitAndMaxFee({
+        gasUsed: txCost.gasUsed,
+        maxFee: txCost.maxFee,
+        txParams
       });
-      await this.fund(request, requiredQuantities, maxFee);
-      request.updatePredicateInputs(estimatedInputs);
+      request.gasLimit = txCost.gasUsed;
+      request.maxFee = txCost.maxFee;
+      await this.fund(request, txCost);
       return request;
     }
     /**
@@ -41982,7 +43110,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param destination - The address of the destination.
      * @param amount - The amount of coins to transfer.
      * @param assetId - The asset ID of the coins to transfer.
-     * @param txParams - The transaction parameters (gasLimit, gasPrice, maturity).
+     * @param txParams - The transaction parameters (gasLimit, maturity).
      * @returns A promise that resolves to the transaction response.
      */
     async transfer(destination, amount, assetId, txParams = {}) {
@@ -42013,32 +43141,30 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         );
       }
       const contractAddress = Address.fromAddressOrString(contractId);
-      const { minGasPrice } = this.provider.getGasConfig();
       const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
-      const params = { gasPrice: minGasPrice, ...txParams };
       const { script, scriptData } = await assembleTransferToContractScript({
         hexlifiedContractId: contractAddress.toB256(),
         amountToTransfer: bn(amount),
         assetId: assetIdToTransfer
       });
       const request = new ScriptTransactionRequest({
-        ...params,
+        ...txParams,
         script,
         scriptData
       });
       request.addContractInputAndOutput(contractAddress);
-      const { maxFee, requiredQuantities, gasUsed } = await this.provider.getTransactionCost(
-        request,
-        [{ amount: bn(amount), assetId: String(assetIdToTransfer) }]
-      );
-      request.gasLimit = bn(params.gasLimit ?? gasUsed);
-      this.validateGas({
-        gasUsed,
-        gasPrice: request.gasPrice,
-        gasLimit: request.gasLimit,
-        minGasPrice
+      const txCost = await this.provider.getTransactionCost(request, {
+        resourcesOwner: this,
+        quantitiesToContract: [{ amount: bn(amount), assetId: String(assetIdToTransfer) }]
+      });
+      this.validateGasLimitAndMaxFee({
+        gasUsed: txCost.gasUsed,
+        maxFee: txCost.maxFee,
+        txParams
       });
-      await this.fund(request, requiredQuantities, maxFee);
+      request.gasLimit = txCost.gasUsed;
+      request.maxFee = txCost.maxFee;
+      await this.fund(request, txCost);
       return this.sendTransaction(request);
     }
     /**
@@ -42050,8 +43176,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @returns A promise that resolves to the transaction response.
      */
     async withdrawToBaseLayer(recipient, amount, txParams = {}) {
-      const { minGasPrice } = this.provider.getGasConfig();
-      const baseAssetId = this.provider.getBaseAssetId();
       const recipientAddress = Address.fromAddressOrString(recipient);
       const recipientDataArray = arrayify(
         "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
@@ -42064,25 +43188,19 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         ...recipientDataArray,
         ...amountDataArray
       ]);
-      const params = {
-        script,
-        gasPrice: minGasPrice,
-        ...txParams
-      };
+      const params = { script, ...txParams };
+      const baseAssetId = this.provider.getBaseAssetId();
       const request = new ScriptTransactionRequest(params);
-      const forwardingQuantities = [{ amount: bn(amount), assetId: baseAssetId }];
-      const { requiredQuantities, maxFee, gasUsed } = await this.provider.getTransactionCost(
-        request,
-        forwardingQuantities
-      );
-      request.gasLimit = bn(params.gasLimit ?? gasUsed);
-      this.validateGas({
-        gasUsed,
-        gasPrice: request.gasPrice,
-        gasLimit: request.gasLimit,
-        minGasPrice
+      const quantitiesToContract = [{ amount: bn(amount), assetId: baseAssetId }];
+      const txCost = await this.provider.getTransactionCost(request, { quantitiesToContract });
+      this.validateGasLimitAndMaxFee({
+        gasUsed: txCost.gasUsed,
+        maxFee: txCost.maxFee,
+        txParams
       });
-      await this.fund(request, requiredQuantities, maxFee);
+      request.maxFee = txCost.maxFee;
+      request.gasLimit = txCost.gasUsed;
+      await this.fund(request, txCost);
       return this.sendTransaction(request);
     }
     async signMessage(message) {
@@ -42140,31 +43258,30 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
       return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
     }
-    validateGas({
+    validateGasLimitAndMaxFee({
+      txParams: { gasLimit: setGasLimit, maxFee: setMaxFee },
       gasUsed,
-      gasPrice,
-      gasLimit,
-      minGasPrice
+      maxFee
     }) {
-      if (minGasPrice.gt(gasPrice)) {
+      if (isDefined(setGasLimit) && gasUsed.gt(setGasLimit)) {
         throw new FuelError(
-          ErrorCode.GAS_PRICE_TOO_LOW,
-          `Gas price '${gasPrice}' is lower than the required: '${minGasPrice}'.`
+          ErrorCode.GAS_LIMIT_TOO_LOW,
+          `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
         );
       }
-      if (gasUsed.gt(gasLimit)) {
+      if (isDefined(setMaxFee) && maxFee.gt(setMaxFee)) {
         throw new FuelError(
-          ErrorCode.GAS_LIMIT_TOO_LOW,
-          `Gas limit '${gasLimit}' is lower than the required: '${gasUsed}'.`
+          ErrorCode.MAX_FEE_TOO_LOW,
+          `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
         );
       }
     }
   };
 
   // ../../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);
@@ -42173,38 +43290,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;
@@ -42212,19 +43329,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))
@@ -42232,7 +43349,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");
@@ -42249,7 +43366,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);
@@ -42260,7 +43377,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))
@@ -42271,10 +43388,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");
@@ -42318,19 +43435,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;
   }
@@ -42357,7 +43474,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)
@@ -42368,16 +43485,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),
@@ -42423,13 +43540,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();
@@ -42446,11 +43563,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;
       },
@@ -42500,7 +43617,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;
@@ -42624,9 +43741,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) {
@@ -42651,7 +43768,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))
@@ -42895,10 +44012,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)
@@ -42907,14 +44024,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();
@@ -42961,7 +44078,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;
       }
@@ -42984,7 +44101,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);
@@ -42992,7 +44109,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);
@@ -43037,7 +44154,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);
@@ -43067,7 +44184,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);
@@ -43083,7 +44200,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) {
@@ -43226,7 +44343,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);
     }
@@ -43256,12 +44373,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);
@@ -43353,9 +44470,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);
@@ -43364,7 +44481,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;
@@ -43373,7 +44490,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;
@@ -43406,7 +44523,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");
@@ -43427,7 +44544,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
     }
   }, sha256);
-  var _0n6 = BigInt(0);
+  var _0n7 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
   // src/signer/signer.ts
@@ -43534,12 +44651,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);
@@ -43555,9 +44672,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
@@ -43740,7 +44857,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param transactionRequestLike - The transaction request to send.
      * @returns A promise that resolves to the TransactionResponse object.
      */
-    async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution } = {}) {
+    async sendTransaction(transactionRequestLike, { estimateTxDependencies = false, awaitExecution } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
       if (estimateTxDependencies) {
         await this.provider.estimateTxDependencies(transactionRequest);
@@ -47018,35 +48135,21 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       const { policies } = BaseTransactionRequest.getPolicyMeta(request);
       request.inputs?.forEach((input) => {
         if (input.type === InputType.Coin && hexlify(input.owner) === this.address.toB256()) {
-          input.predicate = this.bytes;
-          input.predicateData = this.getPredicateData(policies.length);
+          input.predicate = hexlify(this.bytes);
+          input.predicateData = hexlify(this.getPredicateData(policies.length));
         }
       });
       return request;
     }
-    /**
-     * A helper that creates a transfer transaction request and returns it.
-     *
-     * @param destination - The address of the destination.
-     * @param amount - The amount of coins to transfer.
-     * @param assetId - The asset ID of the coins to transfer.
-     * @param txParams - The transaction parameters (gasLimit, gasPrice, maturity).
-     * @returns A promise that resolves to the prepared transaction request.
-     */
-    async createTransfer(destination, amount, assetId, txParams = {}) {
-      const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
-      const request = await super.createTransfer(destination, amount, assetIdToTransfer, txParams);
-      return this.populateTransactionPredicateData(request);
-    }
     /**
      * Sends a transaction with the populated predicate data.
      *
      * @param transactionRequestLike - The transaction request-like object.
      * @returns A promise that resolves to the transaction response.
      */
-    sendTransaction(transactionRequestLike, options) {
-      const transactionRequest = this.populateTransactionPredicateData(transactionRequestLike);
-      return super.sendTransaction(transactionRequest, options);
+    sendTransaction(transactionRequestLike) {
+      const transactionRequest = transactionRequestify(transactionRequestLike);
+      return super.sendTransaction(transactionRequest, { estimateTxDependencies: false });
     }
     /**
      * Simulates a transaction with the populated predicate data.
@@ -47055,8 +48158,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @returns A promise that resolves to the call result.
      */
     simulateTransaction(transactionRequestLike) {
-      const transactionRequest = this.populateTransactionPredicateData(transactionRequestLike);
-      return super.simulateTransaction(transactionRequest);
+      const transactionRequest = transactionRequestify(transactionRequestLike);
+      return super.simulateTransaction(transactionRequest, { estimateTxDependencies: false });
     }
     getPredicateData(policiesLength) {
       if (!this.predicateData.length) {
@@ -47102,6 +48205,25 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         predicateInterface: abiInterface
       };
     }
+    /**
+     * Retrieves resources satisfying the spend query for the account.
+     *
+     * @param quantities - IDs of coins to exclude.
+     * @param excludedIds - IDs of resources to be excluded from the query.
+     * @returns A promise that resolves to an array of Resources.
+     */
+    async getResourcesToSpend(quantities, excludedIds) {
+      const resources = await this.provider.getResourcesToSpend(
+        this.address,
+        quantities,
+        excludedIds
+      );
+      return resources.map((resource) => ({
+        ...resource,
+        predicate: hexlify(this.bytes),
+        padPredicateData: (policiesLength) => hexlify(this.getPredicateData(policiesLength))
+      }));
+    }
     /**
      * Sets the configurable constants for the predicate.
      *