@fuel-ts/account 0.0.0-rc-2143-20240520152005 → 0.0.0-rc-1356-20240520163254

package/dist/test-utils.global.js

@@ -9511,16 +9511,16 @@ spurious results.`);
         },
         // Document
         Document: {
-          leave: (node) => join2(node.definitions, "\n\n")
+          leave: (node) => join3(node.definitions, "\n\n")
         },
         OperationDefinition: {
           leave(node) {
-            const varDefs = wrap2("(", join2(node.variableDefinitions, ", "), ")");
-            const prefix = join2(
+            const varDefs = wrap2("(", join3(node.variableDefinitions, ", "), ")");
+            const prefix = join3(
               [
                 node.operation,
-                join2([node.name, varDefs]),
-                join2(node.directives, " ")
+                join3([node.name, varDefs]),
+                join3(node.directives, " ")
               ],
               " "
             );
@@ -9528,7 +9528,7 @@ spurious results.`);
           }
         },
         VariableDefinition: {
-          leave: ({ variable, type: type3, defaultValue, directives }) => variable + ": " + type3 + wrap2(" = ", defaultValue) + wrap2(" ", join2(directives, " "))
+          leave: ({ variable, type: type3, defaultValue, directives }) => variable + ": " + type3 + wrap2(" = ", defaultValue) + wrap2(" ", join3(directives, " "))
         },
         SelectionSet: {
           leave: ({ selections }) => block2(selections)
@@ -9536,11 +9536,11 @@ spurious results.`);
         Field: {
           leave({ alias, name, arguments: args, directives, selectionSet }) {
             const prefix = wrap2("", alias, ": ") + name;
-            let argsLine = prefix + wrap2("(", join2(args, ", "), ")");
+            let argsLine = prefix + wrap2("(", join3(args, ", "), ")");
             if (argsLine.length > MAX_LINE_LENGTH2) {
-              argsLine = prefix + wrap2("(\n", indent2(join2(args, "\n")), "\n)");
+              argsLine = prefix + wrap2("(\n", indent2(join3(args, "\n")), "\n)");
             }
-            return join2([argsLine, join2(directives, " "), selectionSet], " ");
+            return join3([argsLine, join3(directives, " "), selectionSet], " ");
           }
         },
         Argument: {
@@ -9548,14 +9548,14 @@ spurious results.`);
         },
         // Fragments
         FragmentSpread: {
-          leave: ({ name, directives }) => "..." + name + wrap2(" ", join2(directives, " "))
+          leave: ({ name, directives }) => "..." + name + wrap2(" ", join3(directives, " "))
         },
         InlineFragment: {
-          leave: ({ typeCondition, directives, selectionSet }) => join2(
+          leave: ({ typeCondition, directives, selectionSet }) => join3(
             [
               "...",
               wrap2("on ", typeCondition),
-              join2(directives, " "),
+              join3(directives, " "),
               selectionSet
             ],
             " "
@@ -9564,7 +9564,7 @@ spurious results.`);
         FragmentDefinition: {
           leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => (
             // or removed in the future.
-            `fragment ${name}${wrap2("(", join2(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap2("", join2(directives, " "), " ")}` + selectionSet
+            `fragment ${name}${wrap2("(", join3(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap2("", join3(directives, " "), " ")}` + selectionSet
           )
         },
         // Value
@@ -9587,17 +9587,17 @@ spurious results.`);
           leave: ({ value }) => value
         },
         ListValue: {
-          leave: ({ values }) => "[" + join2(values, ", ") + "]"
+          leave: ({ values }) => "[" + join3(values, ", ") + "]"
         },
         ObjectValue: {
-          leave: ({ fields }) => "{" + join2(fields, ", ") + "}"
+          leave: ({ fields }) => "{" + join3(fields, ", ") + "}"
         },
         ObjectField: {
           leave: ({ name, value }) => name + ": " + value
         },
         // Directive
         Directive: {
-          leave: ({ name, arguments: args }) => "@" + name + wrap2("(", join2(args, ", "), ")")
+          leave: ({ name, arguments: args }) => "@" + name + wrap2("(", join3(args, ", "), ")")
         },
         // Type
         NamedType: {
@@ -9611,122 +9611,122 @@ spurious results.`);
         },
         // Type System Definitions
         SchemaDefinition: {
-          leave: ({ description, directives, operationTypes }) => wrap2("", description, "\n") + join2(["schema", join2(directives, " "), block2(operationTypes)], " ")
+          leave: ({ description, directives, operationTypes }) => wrap2("", description, "\n") + join3(["schema", join3(directives, " "), block2(operationTypes)], " ")
         },
         OperationTypeDefinition: {
           leave: ({ operation, type: type3 }) => operation + ": " + type3
         },
         ScalarTypeDefinition: {
-          leave: ({ description, name, directives }) => wrap2("", description, "\n") + join2(["scalar", name, join2(directives, " ")], " ")
+          leave: ({ description, name, directives }) => wrap2("", description, "\n") + join3(["scalar", name, join3(directives, " ")], " ")
         },
         ObjectTypeDefinition: {
-          leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join2(
+          leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join3(
             [
               "type",
               name,
-              wrap2("implements ", join2(interfaces, " & ")),
-              join2(directives, " "),
+              wrap2("implements ", join3(interfaces, " & ")),
+              join3(directives, " "),
               block2(fields)
             ],
             " "
           )
         },
         FieldDefinition: {
-          leave: ({ description, name, arguments: args, type: type3, directives }) => wrap2("", description, "\n") + name + (hasMultilineItems2(args) ? wrap2("(\n", indent2(join2(args, "\n")), "\n)") : wrap2("(", join2(args, ", "), ")")) + ": " + type3 + wrap2(" ", join2(directives, " "))
+          leave: ({ description, name, arguments: args, type: type3, directives }) => wrap2("", description, "\n") + name + (hasMultilineItems2(args) ? wrap2("(\n", indent2(join3(args, "\n")), "\n)") : wrap2("(", join3(args, ", "), ")")) + ": " + type3 + wrap2(" ", join3(directives, " "))
         },
         InputValueDefinition: {
-          leave: ({ description, name, type: type3, defaultValue, directives }) => wrap2("", description, "\n") + join2(
-            [name + ": " + type3, wrap2("= ", defaultValue), join2(directives, " ")],
+          leave: ({ description, name, type: type3, defaultValue, directives }) => wrap2("", description, "\n") + join3(
+            [name + ": " + type3, wrap2("= ", defaultValue), join3(directives, " ")],
             " "
           )
         },
         InterfaceTypeDefinition: {
-          leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join2(
+          leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join3(
             [
               "interface",
               name,
-              wrap2("implements ", join2(interfaces, " & ")),
-              join2(directives, " "),
+              wrap2("implements ", join3(interfaces, " & ")),
+              join3(directives, " "),
               block2(fields)
             ],
             " "
           )
         },
         UnionTypeDefinition: {
-          leave: ({ description, name, directives, types }) => wrap2("", description, "\n") + join2(
-            ["union", name, join2(directives, " "), wrap2("= ", join2(types, " | "))],
+          leave: ({ description, name, directives, types }) => wrap2("", description, "\n") + join3(
+            ["union", name, join3(directives, " "), wrap2("= ", join3(types, " | "))],
             " "
           )
         },
         EnumTypeDefinition: {
-          leave: ({ description, name, directives, values }) => wrap2("", description, "\n") + join2(["enum", name, join2(directives, " "), block2(values)], " ")
+          leave: ({ description, name, directives, values }) => wrap2("", description, "\n") + join3(["enum", name, join3(directives, " "), block2(values)], " ")
         },
         EnumValueDefinition: {
-          leave: ({ description, name, directives }) => wrap2("", description, "\n") + join2([name, join2(directives, " ")], " ")
+          leave: ({ description, name, directives }) => wrap2("", description, "\n") + join3([name, join3(directives, " ")], " ")
         },
         InputObjectTypeDefinition: {
-          leave: ({ description, name, directives, fields }) => wrap2("", description, "\n") + join2(["input", name, join2(directives, " "), block2(fields)], " ")
+          leave: ({ description, name, directives, fields }) => wrap2("", description, "\n") + join3(["input", name, join3(directives, " "), block2(fields)], " ")
         },
         DirectiveDefinition: {
-          leave: ({ description, name, arguments: args, repeatable, locations }) => wrap2("", description, "\n") + "directive @" + name + (hasMultilineItems2(args) ? wrap2("(\n", indent2(join2(args, "\n")), "\n)") : wrap2("(", join2(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join2(locations, " | ")
+          leave: ({ description, name, arguments: args, repeatable, locations }) => wrap2("", description, "\n") + "directive @" + name + (hasMultilineItems2(args) ? wrap2("(\n", indent2(join3(args, "\n")), "\n)") : wrap2("(", join3(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join3(locations, " | ")
         },
         SchemaExtension: {
-          leave: ({ directives, operationTypes }) => join2(
-            ["extend schema", join2(directives, " "), block2(operationTypes)],
+          leave: ({ directives, operationTypes }) => join3(
+            ["extend schema", join3(directives, " "), block2(operationTypes)],
             " "
           )
         },
         ScalarTypeExtension: {
-          leave: ({ name, directives }) => join2(["extend scalar", name, join2(directives, " ")], " ")
+          leave: ({ name, directives }) => join3(["extend scalar", name, join3(directives, " ")], " ")
         },
         ObjectTypeExtension: {
-          leave: ({ name, interfaces, directives, fields }) => join2(
+          leave: ({ name, interfaces, directives, fields }) => join3(
             [
               "extend type",
               name,
-              wrap2("implements ", join2(interfaces, " & ")),
-              join2(directives, " "),
+              wrap2("implements ", join3(interfaces, " & ")),
+              join3(directives, " "),
               block2(fields)
             ],
             " "
           )
         },
         InterfaceTypeExtension: {
-          leave: ({ name, interfaces, directives, fields }) => join2(
+          leave: ({ name, interfaces, directives, fields }) => join3(
             [
               "extend interface",
               name,
-              wrap2("implements ", join2(interfaces, " & ")),
-              join2(directives, " "),
+              wrap2("implements ", join3(interfaces, " & ")),
+              join3(directives, " "),
               block2(fields)
             ],
             " "
           )
         },
         UnionTypeExtension: {
-          leave: ({ name, directives, types }) => join2(
+          leave: ({ name, directives, types }) => join3(
             [
               "extend union",
               name,
-              join2(directives, " "),
-              wrap2("= ", join2(types, " | "))
+              join3(directives, " "),
+              wrap2("= ", join3(types, " | "))
             ],
             " "
           )
         },
         EnumTypeExtension: {
-          leave: ({ name, directives, values }) => join2(["extend enum", name, join2(directives, " "), block2(values)], " ")
+          leave: ({ name, directives, values }) => join3(["extend enum", name, join3(directives, " "), block2(values)], " ")
         },
         InputObjectTypeExtension: {
-          leave: ({ name, directives, fields }) => join2(["extend input", name, join2(directives, " "), block2(fields)], " ")
+          leave: ({ name, directives, fields }) => join3(["extend input", name, join3(directives, " "), block2(fields)], " ")
         }
       };
-      function join2(maybeArray, separator = "") {
+      function join3(maybeArray, separator = "") {
         var _maybeArray$filter$jo;
         return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : "";
       }
       function block2(array) {
-        return wrap2("{\n", indent2(join2(array, "\n")), "\n}");
+        return wrap2("{\n", indent2(join3(array, "\n")), "\n}");
       }
       function wrap2(start, maybeString, end = "") {
         return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
@@ -32933,6 +32933,13 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var DateTime = _DateTime;
   __publicField3(DateTime, "TAI64_NULL", "");
+  function sleep(time) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, time);
+    });
+  }
   var chainConfig_default = {
     chain_name: "local_testnet",
     consensus_parameters: {
@@ -33687,9 +33694,9 @@ This unreleased fuel-core build may include features and updates not yet support
     da_block_height: 0
   };
   var defaultSnapshotConfigs = {
-    chainConfigJson: chainConfig_default,
-    metadataJson: metadata_default,
-    stateConfigJson: stateConfig_default
+    chainConfig: chainConfig_default,
+    metadata: metadata_default,
+    stateConfig: stateConfig_default
   };
   var defaultConsensusKey = "0xa449b1ffee0e2205fa924c6740cc48b3b473aa28587df6dab12abc245d1f5298";
   function isDefined(value) {
@@ -34429,11 +34436,72 @@ This unreleased fuel-core build may include features and updates not yet support
     };
   }
 
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry2.js
+  function _curry2(fn) {
+    return function f2(a, b) {
+      switch (arguments.length) {
+        case 0:
+          return f2;
+        case 1:
+          return _isPlaceholder(a) ? f2 : _curry1(function(_b) {
+            return fn(a, _b);
+          });
+        default:
+          return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function(_a) {
+            return fn(_a, b);
+          }) : _isPlaceholder(b) ? _curry1(function(_b) {
+            return fn(a, _b);
+          }) : fn(a, b);
+      }
+    };
+  }
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry3.js
+  function _curry3(fn) {
+    return function f3(a, b, c) {
+      switch (arguments.length) {
+        case 0:
+          return f3;
+        case 1:
+          return _isPlaceholder(a) ? f3 : _curry2(function(_b, _c) {
+            return fn(a, _b, _c);
+          });
+        case 2:
+          return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function(_a, _c) {
+            return fn(_a, b, _c);
+          }) : _isPlaceholder(b) ? _curry2(function(_b, _c) {
+            return fn(a, _b, _c);
+          }) : _curry1(function(_c) {
+            return fn(a, b, _c);
+          });
+        default:
+          return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) {
+            return fn(_a, _b, c);
+          }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) {
+            return fn(_a, b, _c);
+          }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) {
+            return fn(a, _b, _c);
+          }) : _isPlaceholder(a) ? _curry1(function(_a) {
+            return fn(_a, b, c);
+          }) : _isPlaceholder(b) ? _curry1(function(_b) {
+            return fn(a, _b, c);
+          }) : _isPlaceholder(c) ? _curry1(function(_c) {
+            return fn(a, b, _c);
+          }) : fn(a, b, c);
+      }
+    };
+  }
+
   // ../../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/internal/_has.js
+  function _has(prop, obj) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+
   // ../../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);
@@ -34450,6 +34518,11 @@ This unreleased fuel-core build may include features and updates not yet support
     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/_isObject.js
+  function _isObject(x) {
+    return Object.prototype.toString.call(x) === "[object Object]";
+  }
+
   // ../../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;
@@ -34563,6 +34636,46 @@ This unreleased fuel-core build may include features and updates not yet support
   });
   var clone_default = clone;
 
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeWithKey.js
+  var mergeWithKey = /* @__PURE__ */ _curry3(function mergeWithKey2(fn, l, r) {
+    var result = {};
+    var k;
+    l = l || {};
+    r = r || {};
+    for (k in l) {
+      if (_has(k, l)) {
+        result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
+      }
+    }
+    for (k in r) {
+      if (_has(k, r) && !_has(k, result)) {
+        result[k] = r[k];
+      }
+    }
+    return result;
+  });
+  var mergeWithKey_default = mergeWithKey;
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeDeepWithKey.js
+  var mergeDeepWithKey = /* @__PURE__ */ _curry3(function mergeDeepWithKey2(fn, lObj, rObj) {
+    return mergeWithKey_default(function(k, lVal, rVal) {
+      if (_isObject(lVal) && _isObject(rVal)) {
+        return mergeDeepWithKey2(fn, lVal, rVal);
+      } else {
+        return fn(k, lVal, rVal);
+      }
+    }, lObj, rObj);
+  });
+  var mergeDeepWithKey_default = mergeDeepWithKey;
+
+  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeDeepRight.js
+  var mergeDeepRight = /* @__PURE__ */ _curry2(function mergeDeepRight2(lObj, rObj) {
+    return mergeDeepWithKey_default(function(k, lVal, rVal) {
+      return rVal;
+    }, lObj, rObj);
+  });
+  var mergeDeepRight_default = mergeDeepRight;
+
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/trim.js
   var hasProtoTrim = typeof String.prototype.trim === "function";
 
@@ -41970,15 +42083,6 @@ ${MessageCoinFragmentDoc}`;
     return normalize2(clone_default(root));
   }
 
-  // src/providers/utils/sleep.ts
-  function sleep(time) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(true);
-      }, time);
-    });
-  }
-
   // src/providers/utils/extract-tx-error.ts
   var assemblePanicError = (statusReason) => {
     let errorMessage = `The transaction reverted with reason: "${statusReason}".`;
@@ -49949,12 +50053,27 @@ Supported fuel-core version: ${supportedVersion}.`
     return wallet;
   };
 
+  // ../utils/dist/cli-utils.mjs
+  var import_fs = __require("fs");
+  var import_path7 = __require("path");
+  var findBinPath = (binCommandName, startingDir) => {
+    const cmdPath = (0, import_path7.join)(startingDir, "node_modules", ".bin", binCommandName);
+    const parentDir = (0, import_path7.join)(startingDir, "..");
+    if ((0, import_fs.existsSync)(cmdPath)) {
+      return cmdPath;
+    }
+    if (parentDir === startingDir) {
+      throw new Error(`Command not found: ${binCommandName}`);
+    }
+    return findBinPath(binCommandName, parentDir);
+  };
+
   // src/test-utils/launchNode.ts
   var import_child_process = __require("child_process");
   var import_crypto19 = __require("crypto");
-  var import_fs = __require("fs");
+  var import_fs2 = __require("fs");
   var import_os = __toESM(__require("os"));
-  var import_path7 = __toESM(__require("path"));
+  var import_path8 = __toESM(__require("path"));
   var import_portfinder = __toESM(require_portfinder());
   var import_tree_kill = __toESM(require_tree_kill());
   var getFlagValueFromArgs = (args, flag) => {
@@ -49983,19 +50102,54 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       child.stdout.removeAllListeners();
       child.stderr.removeAllListeners();
-      if ((0, import_fs.existsSync)(configPath)) {
-        (0, import_fs.rmSync)(configPath, { recursive: true });
+      if ((0, import_fs2.existsSync)(configPath)) {
+        (0, import_fs2.rmSync)(configPath, { recursive: true });
       }
     }
   };
+  function getFinalStateConfigJSON({ stateConfig, chainConfig }) {
+    const defaultCoins = defaultSnapshotConfigs.stateConfig.coins.map((coin) => ({
+      ...coin,
+      amount: "18446744073709551615"
+    }));
+    const defaultMessages = defaultSnapshotConfigs.stateConfig.messages.map((message) => ({
+      ...message,
+      amount: "18446744073709551615"
+    }));
+    const coins = defaultCoins.concat(stateConfig.coins.map((coin) => ({ ...coin, amount: coin.amount.toString() }))).filter((coin, index, self2) => self2.findIndex((c) => c.tx_id === coin.tx_id) === index);
+    const messages = defaultMessages.concat(stateConfig.messages.map((msg) => ({ ...msg, amount: msg.amount.toString() }))).filter((msg, index, self2) => self2.findIndex((m) => m.nonce === msg.nonce) === index);
+    if (!process.env.GENESIS_SECRET) {
+      const pk = Signer.generatePrivateKey();
+      const signer = new Signer(pk);
+      process.env.GENESIS_SECRET = hexlify(pk);
+      coins.push({
+        tx_id: hexlify(randomBytes22(UTXO_ID_LEN)),
+        owner: signer.address.toHexString(),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        amount: "18446744073709551615",
+        asset_id: chainConfig.consensus_parameters.V1.base_asset_id,
+        output_index: 0,
+        tx_pointer_block_height: 0,
+        tx_pointer_tx_idx: 0
+      });
+    }
+    const json = JSON.stringify({
+      ...stateConfig,
+      coins,
+      messages
+    });
+    const regexMakeNumber = /("amount":)"(\d+)"/gm;
+    return json.replace(regexMakeNumber, "$1$2");
+  }
   var launchNode = async ({
     ip,
     port,
     args = [],
-    fuelCorePath = process.env.FUEL_CORE_PATH ?? void 0,
+    useSystemFuelCore = false,
     loggingEnabled = true,
     debugEnabled = false,
-    basePath
+    basePath,
+    snapshotConfig = defaultSnapshotConfigs
   }) => (
     // eslint-disable-next-line no-async-promise-executor
     new Promise(async (resolve, reject) => {
@@ -50012,7 +50166,8 @@ Supported fuel-core version: ${supportedVersion}.`
       const poaInstantFlagValue = getFlagValueFromArgs(args, "--poa-instant");
       const poaInstant = poaInstantFlagValue === "true" || poaInstantFlagValue === void 0;
       const graphQLStartSubstring = "Binding GraphQL provider to";
-      const command = fuelCorePath ?? "fuel-core";
+      const binPath = findBinPath("fuels-core", __dirname);
+      const command = useSystemFuelCore ? "fuel-core" : binPath;
       const ipToUse = ip || "0.0.0.0";
       const portToUse = port || (await (0, import_portfinder.getPortPromise)({
         port: 4e3,
@@ -50023,56 +50178,23 @@ Supported fuel-core version: ${supportedVersion}.`
       let snapshotDirToUse;
       const prefix = basePath || import_os.default.tmpdir();
       const suffix = basePath ? "" : (0, import_crypto19.randomUUID)();
-      const tempDirPath = import_path7.default.join(prefix, ".fuels", suffix, "snapshotDir");
+      const tempDir = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
       if (snapshotDir) {
         snapshotDirToUse = snapshotDir;
       } else {
-        if (!(0, import_fs.existsSync)(tempDirPath)) {
-          (0, import_fs.mkdirSync)(tempDirPath, { recursive: true });
-        }
-        let { stateConfigJson } = defaultSnapshotConfigs;
-        const { chainConfigJson, metadataJson } = defaultSnapshotConfigs;
-        stateConfigJson = {
-          ...stateConfigJson,
-          coins: [
-            ...stateConfigJson.coins.map((coin) => ({
-              ...coin,
-              amount: "18446744073709551615"
-            }))
-          ],
-          messages: stateConfigJson.messages.map((message) => ({
-            ...message,
-            amount: "18446744073709551615"
-          }))
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        };
-        if (!process.env.GENESIS_SECRET) {
-          const pk = Signer.generatePrivateKey();
-          const signer = new Signer(pk);
-          process.env.GENESIS_SECRET = hexlify(pk);
-          stateConfigJson.coins.push({
-            tx_id: hexlify(randomBytes22(UTXO_ID_LEN)),
-            owner: signer.address.toHexString(),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            amount: "18446744073709551615",
-            asset_id: chainConfigJson.consensus_parameters.V1.base_asset_id,
-            output_index: 0,
-            tx_pointer_block_height: 0,
-            tx_pointer_tx_idx: 0
-          });
-        }
-        let fixedStateConfigJSON = JSON.stringify(stateConfigJson);
-        const regexMakeNumber = /("amount":)"(\d+)"/gm;
-        fixedStateConfigJSON = fixedStateConfigJSON.replace(regexMakeNumber, "$1$2");
-        const chainConfigWritePath = import_path7.default.join(tempDirPath, "chainConfig.json");
-        const stateConfigWritePath = import_path7.default.join(tempDirPath, "stateConfig.json");
-        const metadataWritePath = import_path7.default.join(tempDirPath, "metadata.json");
-        const stateTransitionWritePath = import_path7.default.join(tempDirPath, "state_transition_bytecode.wasm");
-        (0, import_fs.writeFileSync)(chainConfigWritePath, JSON.stringify(chainConfigJson), "utf8");
-        (0, import_fs.writeFileSync)(stateConfigWritePath, fixedStateConfigJSON, "utf8");
-        (0, import_fs.writeFileSync)(metadataWritePath, JSON.stringify(metadataJson), "utf8");
-        (0, import_fs.writeFileSync)(stateTransitionWritePath, JSON.stringify(""));
-        snapshotDirToUse = tempDirPath;
+        if (!(0, import_fs2.existsSync)(tempDir)) {
+          (0, import_fs2.mkdirSync)(tempDir, { recursive: true });
+        }
+        const { metadata } = snapshotConfig;
+        const metadataPath = import_path8.default.join(tempDir, "metadata.json");
+        const chainConfigPath = import_path8.default.join(tempDir, metadata.chain_config);
+        const stateConfigPath = import_path8.default.join(tempDir, metadata.table_encoding.Json.filepath);
+        const stateTransitionPath = import_path8.default.join(tempDir, "state_transition_bytecode.wasm");
+        (0, import_fs2.writeFileSync)(chainConfigPath, JSON.stringify(snapshotConfig.chainConfig), "utf8");
+        (0, import_fs2.writeFileSync)(stateConfigPath, getFinalStateConfigJSON(snapshotConfig), "utf8");
+        (0, import_fs2.writeFileSync)(metadataPath, JSON.stringify(metadata), "utf8");
+        (0, import_fs2.writeFileSync)(stateTransitionPath, JSON.stringify(""));
+        snapshotDirToUse = tempDir;
       }
       const child = (0, import_child_process.spawn)(
         command,
@@ -50080,7 +50202,7 @@ Supported fuel-core version: ${supportedVersion}.`
           "run",
           ["--ip", ipToUse],
           ["--port", portToUse],
-          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDirPath],
+          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDir],
           ["--min-gas-price", "1"],
           poaInstant ? ["--poa-instant", "true"] : [],
           ["--consensus-key", consensusKey],
@@ -50102,23 +50224,28 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       const cleanupConfig = {
         child,
-        configPath: tempDirPath,
+        configPath: tempDir,
         killFn: import_tree_kill.default,
         state: {
           isDead: false
         }
       };
       child.stderr.on("data", (chunk) => {
-        if (chunk.indexOf(graphQLStartSubstring) !== -1) {
+        const text = typeof chunk === "string" ? chunk : chunk.toString();
+        if (text.indexOf(graphQLStartSubstring) !== -1) {
+          const rows = text.split("\n");
+          const rowWithUrl = rows.find((row) => row.indexOf(graphQLStartSubstring) !== -1);
+          const [realIp, realPort] = rowWithUrl.split(" ").at(-1).trim().split(":");
           resolve({
             cleanup: () => killNode(cleanupConfig),
-            ip: ipToUse,
-            port: portToUse,
+            ip: realIp,
+            port: realPort,
+            url: `http://${realIp}:${realPort}/v1/graphql`,
             snapshotDir: snapshotDirToUse
           });
         }
-        if (/error/i.test(chunk)) {
-          reject(chunk.toString());
+        if (/error/i.test(text)) {
+          reject(text.toString());
         }
       });
       process.on("exit", () => killNode(cleanupConfig));
@@ -50151,6 +50278,222 @@ Supported fuel-core version: ${supportedVersion}.`
     };
     return { wallets, stop: cleanup, provider };
   };
+
+  // src/test-utils/asset-id.ts
+  var _AssetId = class {
+    constructor(value) {
+      this.value = value;
+    }
+    static random(count = 1) {
+      const assetIds = [];
+      for (let i = 0; i < count; i++) {
+        assetIds.push(new _AssetId(hexlify(randomBytes22(32))));
+      }
+      return assetIds;
+    }
+  };
+  var AssetId = _AssetId;
+  __publicField(AssetId, "A", new _AssetId(
+    "0x0101010101010101010101010101010101010101010101010101010101010101"
+  ));
+  __publicField(AssetId, "B", new _AssetId(
+    "0x0202020202020202020202020202020202020202020202020202020202020202"
+  ));
+
+  // src/test-utils/wallet-config.ts
+  var WalletConfig = class {
+    initialState;
+    options;
+    wallets;
+    generateWallets = () => {
+      const generatedWallets = [];
+      for (let index = 1; index <= this.options.count; index++) {
+        generatedWallets.push(new WalletUnlocked(randomBytes22(32)));
+      }
+      return generatedWallets;
+    };
+    constructor(baseAssetId, config) {
+      WalletConfig.validate(config);
+      this.options = config;
+      const { assets: assets2, coinsPerAsset, amountPerCoin, messages } = this.options;
+      this.wallets = this.generateWallets();
+      this.initialState = {
+        messages: WalletConfig.createMessages(this.wallets, messages),
+        coins: WalletConfig.createCoins(
+          this.wallets,
+          baseAssetId,
+          assets2,
+          coinsPerAsset,
+          amountPerCoin
+        )
+      };
+    }
+    apply(snapshotConfig) {
+      return {
+        ...snapshotConfig,
+        stateConfig: {
+          ...snapshotConfig?.stateConfig ?? defaultSnapshotConfigs.stateConfig,
+          coins: this.initialState.coins.concat(snapshotConfig?.stateConfig?.coins || []),
+          messages: this.initialState.messages.concat(snapshotConfig?.stateConfig?.messages ?? [])
+        }
+      };
+    }
+    /**
+     * Create messages for the wallets in the format that the chain expects.
+     */
+    static createMessages(wallets, messages) {
+      return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
+    }
+    /**
+     * Create coins for the wallets in the format that the chain expects.
+     */
+    static createCoins(wallets, baseAssetId, assets2, coinsPerAsset, amountPerCoin) {
+      const coins = [];
+      let assetIds = [baseAssetId];
+      if (Array.isArray(assets2)) {
+        assetIds = assetIds.concat(assets2.map((a) => a.value));
+      } else {
+        assetIds.concat(AssetId.random(assets2).map((a) => a.value));
+      }
+      wallets.map((wallet) => wallet.address.toHexString()).forEach((walletAddress) => {
+        assetIds.forEach((assetId) => {
+          for (let index = 0; index < coinsPerAsset; index++) {
+            coins.push({
+              amount: amountPerCoin,
+              asset_id: assetId,
+              owner: walletAddress,
+              tx_pointer_block_height: 0,
+              tx_pointer_tx_idx: 0,
+              output_index: 0,
+              tx_id: hexlify(randomBytes22(32))
+            });
+          }
+        });
+      });
+      return coins;
+    }
+    static validate({
+      count: wallets,
+      assets: assets2,
+      coinsPerAsset,
+      amountPerCoin
+    }) {
+      if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
+        throw new FuelError(
+          FuelError.CODES.INVALID_INPUT_PARAMETERS,
+          "Number of wallets must be greater than zero."
+        );
+      }
+      if (Array.isArray(assets2) && assets2.length === 0 || typeof assets2 === "number" && assets2 <= 0) {
+        throw new FuelError(
+          FuelError.CODES.INVALID_INPUT_PARAMETERS,
+          "Number of assets per wallet must be greater than zero."
+        );
+      }
+      if (coinsPerAsset <= 0) {
+        throw new FuelError(
+          FuelError.CODES.INVALID_INPUT_PARAMETERS,
+          "Number of coins per asset must be greater than zero."
+        );
+      }
+      if (amountPerCoin <= 0) {
+        throw new FuelError(
+          FuelError.CODES.INVALID_INPUT_PARAMETERS,
+          "Amount per coin must be greater than zero."
+        );
+      }
+    }
+  };
+
+  // src/test-utils/setup-test-provider-and-wallets.ts
+  var defaultWalletConfigOptions = {
+    count: 2,
+    assets: [AssetId.A, AssetId.B],
+    coinsPerAsset: 1,
+    amountPerCoin: 1e10,
+    messages: []
+  };
+  async function setupTestProviderAndWallets({
+    walletConfig: walletConfigOptions = {},
+    providerOptions,
+    nodeOptions = {}
+  } = {}) {
+    Symbol.dispose ??= Symbol("Symbol.dispose");
+    const walletConfig = new WalletConfig(
+      nodeOptions.snapshotConfig?.chainConfig?.consensus_parameters?.V1?.base_asset_id ?? defaultSnapshotConfigs.chainConfig.consensus_parameters.V1.base_asset_id,
+      {
+        ...defaultWalletConfigOptions,
+        ...walletConfigOptions
+      }
+    );
+    const { cleanup, url } = await launchNode({
+      loggingEnabled: false,
+      ...nodeOptions,
+      snapshotConfig: mergeDeepRight_default(
+        defaultSnapshotConfigs,
+        walletConfig.apply(nodeOptions?.snapshotConfig)
+      ),
+      port: "0"
+    });
+    let provider;
+    try {
+      provider = await Provider.create(url, providerOptions);
+    } catch (err) {
+      cleanup();
+      throw err;
+    }
+    const wallets = walletConfig.wallets;
+    wallets.forEach((wallet) => {
+      wallet.connect(provider);
+    });
+    return {
+      provider,
+      wallets,
+      cleanup,
+      [Symbol.dispose]: cleanup
+    };
+  }
+
+  // src/test-utils/test-message.ts
+  var TestMessage = class {
+    sender;
+    recipient;
+    nonce;
+    amount;
+    data;
+    da_height;
+    /**
+     * A helper class to create messages for testing purposes.
+     *
+     * Used in tandem with `WalletConfig`.
+     * It can also be used standalone and passed into the initial state of a chain via the `.toChainMessage` method.
+     */
+    constructor({
+      sender = Address.fromRandom(),
+      recipient = Address.fromRandom(),
+      nonce = hexlify(randomBytes22(32)),
+      amount = 1e6,
+      data = "02",
+      da_height = 0
+    } = {}) {
+      this.sender = sender;
+      this.recipient = recipient;
+      this.nonce = nonce;
+      this.amount = amount;
+      this.data = data;
+      this.da_height = da_height;
+    }
+    toChainMessage(recipient) {
+      return {
+        sender: this.sender.toB256(),
+        recipient: recipient?.toB256() ?? this.recipient.toB256(),
+        nonce: this.nonce,
+        amount: bn(this.amount).toNumber(),
+        data: this.data,
+        da_height: this.da_height
+      };
+    }
+  };
 })();
 /*! Bundled license information: