@fuel-ts/account 0.0.0-rc-1815-20240322115843 → 0.0.0-rc-1356-20240322130951

package/dist/test-utils.global.js

@@ -32710,6 +32710,13 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var defaultChainConfig = chainConfig_default;
   var defaultConsensusKey = "0xa449b1ffee0e2205fa924c6740cc48b3b473aa28587df6dab12abc245d1f5298";
+  function sleep(time) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, time);
+    });
+  }
 
   // ../crypto/dist/index.mjs
   var import_crypto8 = __toESM(__require("crypto"), 1);
@@ -38080,11 +38087,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);
@@ -38101,6 +38169,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;
@@ -38214,6 +38287,46 @@ This unreleased fuel-core build may include features and updates not yet support
   });
   var clone_default = clone2;
 
+  // ../../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";
 
@@ -42745,15 +42858,6 @@ ${MessageCoinFragmentFragmentDoc}`;
     return normalize2(clone_default(root));
   }
 
-  // src/providers/utils/sleep.ts
-  function sleep(time) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(true);
-      }, time);
-    });
-  }
-
   // src/providers/transaction-request/errors.ts
   var NoWitnessAtIndexError = class extends Error {
     constructor(index) {
@@ -42882,27 +42986,13 @@ ${MessageCoinFragmentFragmentDoc}`;
       this.outputs.push(output3);
       return this.outputs.length - 1;
     }
-    /**
-     * @hidden
-     *
-     * Pushes a witness to the list and returns the index
-     *
-     * @param signature - The signature to add to the witness.
-     * @returns The index of the created witness.
-     */
-    addWitness(signature) {
-      this.witnesses.push(signature);
-      return this.witnesses.length - 1;
-    }
     /**
      * @hidden
      *
      * Creates an empty witness without any side effects and returns the index
-     *
-     * @returns The index of the created witness.
      */
-    addEmptyWitness() {
-      this.addWitness(concat([ZeroBytes32, ZeroBytes32]));
+    createWitness() {
+      this.witnesses.push(concat([ZeroBytes32, ZeroBytes32]));
       return this.witnesses.length - 1;
     }
     /**
@@ -42931,21 +43021,6 @@ ${MessageCoinFragmentFragmentDoc}`;
       }
       this.witnesses[index] = witness;
     }
-    /**
-     * Helper function to add an external signature to the transaction.
-     *
-     * @param account - The account/s to sign to the transaction.
-     * @returns The transaction with the signature witness added.
-     */
-    async addAccountWitnesses(account) {
-      const accounts = Array.isArray(account) ? account : [account];
-      await Promise.all(
-        accounts.map(async (acc) => {
-          this.addWitness(await acc.signTransaction(this));
-        })
-      );
-      return this;
-    }
     /**
      * Gets the coin inputs for a transaction.
      *
@@ -43011,7 +43086,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       } else {
         witnessIndex = this.getCoinInputWitnessIndexByOwner(owner);
         if (typeof witnessIndex !== "number") {
-          witnessIndex = this.addEmptyWitness();
+          witnessIndex = this.createWitness();
         }
       }
       const input = {
@@ -43045,7 +43120,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       } else {
         witnessIndex = this.getCoinInputWitnessIndexByOwner(recipient);
         if (typeof witnessIndex !== "number") {
-          witnessIndex = this.addEmptyWitness();
+          witnessIndex = this.createWitness();
         }
       }
       const input = {
@@ -45910,21 +45985,6 @@ ${MessageCoinFragmentFragmentDoc}`;
       }
       return this._connector.signMessage(this.address.toString(), message);
     }
-    /**
-     * Signs a transaction with the wallet's private key.
-     *
-     * @param transactionRequestLike - The transaction request to sign.
-     * @returns A promise that resolves to the signature of the transaction.
-     */
-    async signTransaction(transactionRequestLike) {
-      if (!this._connector) {
-        throw new FuelError(
-          ErrorCode.MISSING_CONNECTOR,
-          "A connector is required to sign transactions."
-        );
-      }
-      return this._connector.signTransaction(this.address.toString(), transactionRequestLike);
-    }
     /**
      * Sends a transaction to the network.
      *
@@ -47536,7 +47596,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     async signTransaction(transactionRequestLike) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
-      const chainId = this.provider.getChainId();
+      const chainId = this.provider.getChain().consensusParameters.chainId.toNumber();
       const hashedTransaction = transactionRequest.getTransactionId(chainId);
       const signature = await this.signer().sign(hashedTransaction);
       return hexlify(signature);
@@ -50400,7 +50460,8 @@ ${MessageCoinFragmentFragmentDoc}`;
     useSystemFuelCore = false,
     loggingEnabled = true,
     debugEnabled = false,
-    basePath
+    basePath,
+    chainConfig = defaultChainConfig
   }) => (
     // eslint-disable-next-line no-async-promise-executor
     new Promise(async (resolve, reject) => {
@@ -50437,17 +50498,17 @@ ${MessageCoinFragmentFragmentDoc}`;
           (0, import_fs2.mkdirSync)(tempDirPath, { recursive: true });
         }
         const tempChainConfigFilePath = import_path8.default.join(tempDirPath, "chainConfig.json");
-        let chainConfig = defaultChainConfig;
+        let generatedChainConfig = chainConfig;
         if (!process.env.GENESIS_SECRET) {
           const pk = Signer.generatePrivateKey();
           const signer = new Signer(pk);
           process.env.GENESIS_SECRET = hexlify(pk);
-          chainConfig = {
-            ...defaultChainConfig,
+          generatedChainConfig = {
+            ...generatedChainConfig,
             initial_state: {
-              ...defaultChainConfig.initial_state,
+              ...generatedChainConfig.initial_state,
               coins: [
-                ...defaultChainConfig.initial_state.coins,
+                ...generatedChainConfig.initial_state.coins,
                 {
                   owner: signer.address.toHexString(),
                   amount: toHex(1e9),
@@ -50457,7 +50518,7 @@ ${MessageCoinFragmentFragmentDoc}`;
             }
           };
         }
-        (0, import_fs2.writeFileSync)(tempChainConfigFilePath, JSON.stringify(chainConfig), "utf8");
+        (0, import_fs2.writeFileSync)(tempChainConfigFilePath, JSON.stringify(generatedChainConfig), "utf8");
         chainConfigPathToUse = tempChainConfigFilePath;
       }
       const child = (0, import_child_process.spawn)(
@@ -50495,16 +50556,21 @@ ${MessageCoinFragmentFragmentDoc}`;
         }
       };
       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}/graphql`,
             chainConfigPath: chainConfigPathToUse
           });
         }
-        if (/error/i.test(chunk)) {
-          reject(chunk.toString());
+        if (/error/i.test(text)) {
+          reject(text.toString());
         }
       });
       process.on("exit", () => killNode(cleanupConfig));
@@ -50536,6 +50602,198 @@ ${MessageCoinFragmentFragmentDoc}`;
     };
     return { wallets, stop: cleanup, provider };
   };
+
+  // src/test-utils/asset-id.ts
+  var _AssetId = class {
+    constructor(value) {
+      this.value = value;
+    }
+    static random() {
+      return new _AssetId(hexlify(randomBytes22(32)));
+    }
+  };
+  var AssetId = _AssetId;
+  __publicField(AssetId, "BaseAssetId", new _AssetId(BaseAssetId));
+  __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(config) {
+      WalletConfig.guard(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, assets2, coinsPerAsset, amountPerCoin)
+      };
+    }
+    apply(chainConfig) {
+      return {
+        ...chainConfig,
+        initial_state: {
+          ...chainConfig?.initial_state,
+          coins: this.initialState.coins.concat(chainConfig?.initial_state?.coins || []),
+          messages: this.initialState.messages.concat(chainConfig?.initial_state?.messages ?? [])
+        }
+      };
+    }
+    static createMessages(wallets, messages) {
+      return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
+    }
+    static createCoins(wallets, assets2, coinsPerAsset, amountPerCoin) {
+      const coins = [];
+      let assetIds = [AssetId.BaseAssetId.value];
+      if (Array.isArray(assets2)) {
+        assetIds = assetIds.concat(assets2.map((a) => a.value));
+      } else {
+        for (let index = 0; index < assets2 - 1; index++) {
+          assetIds.push(AssetId.random().value);
+        }
+      }
+      wallets.map((wallet) => wallet.address.toHexString()).forEach((walletAddress) => {
+        assetIds.forEach((assetId) => {
+          for (let index = 0; index < coinsPerAsset; index++) {
+            coins.push({
+              amount: toHex(amountPerCoin, 8),
+              asset_id: assetId,
+              owner: walletAddress
+            });
+          }
+        });
+      });
+      return coins;
+    }
+    static guard({
+      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({
+      ...defaultWalletConfigOptions,
+      ...walletConfigOptions
+    });
+    const { cleanup, url } = await launchNode({
+      ...nodeOptions,
+      chainConfig: mergeDeepRight_default(defaultChainConfig, walletConfig.apply(nodeOptions?.chainConfig)),
+      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 = "0x00"
+    } = {}) {
+      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: new BN(this.amount).toHex(8),
+        data: this.data,
+        da_height: this.da_height
+      };
+    }
+  };
 })();
 /*! Bundled license information: