@fuel-ts/account 0.89.1 → 0.90.0

package/dist/index.mjs

@@ -28,11 +28,13 @@ var __privateMethod = (obj, member, method) => {
 };
 
 // src/account.ts
+import { UTXO_ID_LEN as UTXO_ID_LEN3 } from "@fuel-ts/abi-coder";
 import { Address as Address3 } from "@fuel-ts/address";
+import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
 import { bn as bn19 } from "@fuel-ts/math";
-import { arrayify as arrayify14, isDefined as isDefined2 } from "@fuel-ts/utils";
+import { arrayify as arrayify14, hexlify as hexlify13, isDefined as isDefined2 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
 // src/providers/coin-quantity.ts
@@ -307,6 +309,7 @@ var MessageProofFragmentDoc = gql`
     proofIndex
   }
   messageBlockHeader {
+    version
     id
     daHeight
     consensusParametersVersion
@@ -322,6 +325,7 @@ var MessageProofFragmentDoc = gql`
     applicationHash
   }
   commitBlockHeader {
+    version
     id
     daHeight
     consensusParametersVersion
@@ -508,6 +512,9 @@ var GasCostsFragmentDoc = gql`
   wqmm
   xor
   xori
+  alocDependentCost {
+    ...DependentCostFragment
+  }
   call {
     ...DependentCostFragment
   }
@@ -692,9 +699,13 @@ var GetTransactionsDocument = gql`
         ...transactionFragment
       }
     }
+    pageInfo {
+      ...pageInfoFragment
+    }
   }
 }
-    ${TransactionFragmentDoc}`;
+    ${TransactionFragmentDoc}
+${PageInfoFragmentDoc}`;
 var GetTransactionsByOwnerDocument = gql`
     query getTransactionsByOwner($owner: Address!, $after: String, $before: String, $first: Int, $last: Int) {
   transactionsByOwner(
@@ -886,8 +897,12 @@ var GetRelayedTransactionStatusDocument = gql`
 }
     ${RelayedTransactionStatusFragmentDoc}`;
 var DryRunDocument = gql`
-    mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean) {
-  dryRun(txs: $encodedTransactions, utxoValidation: $utxoValidation) {
+    mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean, $gasPrice: U64) {
+  dryRun(
+    txs: $encodedTransactions
+    utxoValidation: $utxoValidation
+    gasPrice: $gasPrice
+  ) {
     ...dryRunTransactionExecutionStatusFragment
   }
 }
@@ -1714,15 +1729,6 @@ function normalizeJSON(root) {
   return normalize(clone(root));
 }
 
-// src/providers/utils/sleep.ts
-function sleep(time) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true);
-    }, time);
-  });
-}
-
 // src/providers/utils/extract-tx-error.ts
 import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
 import { bn as bn6 } from "@fuel-ts/math";
@@ -3752,6 +3758,7 @@ var TransactionResponse = class {
 };
 
 // src/providers/utils/auto-retry-fetch.ts
+import { sleep } from "@fuel-ts/utils";
 function getWaitDelay(options, retryAttemptNum) {
   const duration = options.baseDelay ?? 150;
   switch (options.backoff) {
@@ -4178,7 +4185,7 @@ Supported fuel-core version: ${supportedVersion}.`
    * @param sendTransactionParams - The provider call parameters (optional).
    * @returns A promise that resolves to the call result object.
    */
-  async call(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
+  async dryRun(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
@@ -4717,6 +4724,21 @@ Supported fuel-core version: ${supportedVersion}.`
       0
     )?.[0];
   }
+  /**
+   * Retrieves transactions based on the provided pagination arguments.
+   * @param paginationArgs - The pagination arguments for retrieving transactions.
+   * @returns A promise that resolves to an object containing the retrieved transactions and pagination information.
+   */
+  async getTransactions(paginationArgs) {
+    const {
+      transactions: { edges, pageInfo }
+    } = await this.operations.getTransactions(paginationArgs);
+    const coder = new TransactionCoder5();
+    const transactions = edges.map(
+      ({ node: { rawPayload } }) => coder.decode(arrayify11(rawPayload), 0)[0]
+    );
+    return { transactions, pageInfo };
+  }
   /**
    * Get deployed contract with the given ID.
    *
@@ -5077,7 +5099,7 @@ async function getTransactionSummary(params) {
 }
 async function getTransactionSummaryFromRequest(params) {
   const { provider, transactionRequest, abiMap } = params;
-  const { receipts } = await provider.call(transactionRequest);
+  const { receipts } = await provider.dryRun(transactionRequest);
   const { gasPerByte, gasPriceFactor, gasCosts, maxGasPerTx } = provider.getGasConfig();
   const maxInputs = provider.getChain().consensusParameters.txParameters.maxInputs;
   const transaction = transactionRequest.toTransaction();
@@ -5155,8 +5177,8 @@ var CHAIN_IDS = {
     foundry: 31337
   },
   fuel: {
-    beta5: 0,
-    devnet: 10
+    devnet: 0,
+    testnet: 0
   }
 };
 
@@ -5166,7 +5188,7 @@ var getDefaultChainId = (networkType) => {
     return CHAIN_IDS.eth.sepolia;
   }
   if (networkType === "fuel") {
-    return CHAIN_IDS.fuel.devnet;
+    return CHAIN_IDS.fuel.testnet;
   }
   return void 0;
 };
@@ -5258,15 +5280,15 @@ var rawAssets = [
       },
       {
         type: "fuel",
-        chainId: CHAIN_IDS.fuel.beta5,
+        chainId: CHAIN_IDS.fuel.devnet,
         decimals: 9,
-        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
       },
       {
         type: "fuel",
-        chainId: CHAIN_IDS.fuel.devnet,
+        chainId: CHAIN_IDS.fuel.testnet,
         decimals: 9,
-        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
       }
     ]
   }
@@ -5780,6 +5802,21 @@ var Account = class extends AbstractAccount {
     }
     return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
   }
+  /**
+   * Generates an array of fake resources based on the provided coins.
+   *
+   * @param coins - An array of `FakeResources` objects representing the coins.
+   * @returns An array of `Resource` objects with generated properties.
+   */
+  generateFakeResources(coins) {
+    return coins.map((coin) => ({
+      id: hexlify13(randomBytes2(UTXO_ID_LEN3)),
+      owner: this.address,
+      blockCreated: bn19(1),
+      txCreatedIdx: bn19(1),
+      ...coin
+    }));
+  }
   /** @hidden * */
   validateTransferAmount(amount) {
     if (bn19(amount).lte(0)) {
@@ -5834,14 +5871,14 @@ var Account = class extends AbstractAccount {
 
 // src/wallet/base-wallet-unlocked.ts
 import { hashMessage } from "@fuel-ts/hasher";
-import { hexlify as hexlify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify16 } from "@fuel-ts/utils";
 
 // src/signer/signer.ts
 import { Address as Address4 } from "@fuel-ts/address";
-import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
 import { hash } from "@fuel-ts/hasher";
 import { toBytes } from "@fuel-ts/math";
-import { hexlify as hexlify13, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify14, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 var Signer = class {
   address;
@@ -5861,9 +5898,9 @@ var Signer = class {
       }
     }
     const privateKeyBytes = toBytes(privateKey, 32);
-    this.privateKey = hexlify13(privateKeyBytes);
-    this.publicKey = hexlify13(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
-    this.compressedPublicKey = hexlify13(secp256k1.getPublicKey(privateKeyBytes, true));
+    this.privateKey = hexlify14(privateKeyBytes);
+    this.publicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
+    this.compressedPublicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, true));
     this.address = Address4.fromPublicKey(this.publicKey);
   }
   /**
@@ -5881,7 +5918,7 @@ var Signer = class {
     const r = toBytes(`0x${signature.r.toString(16)}`, 32);
     const s = toBytes(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return hexlify13(concat3([r, s]));
+    return hexlify14(concat3([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -5908,11 +5945,11 @@ var Signer = class {
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
     s[0] &= 127;
-    const sig = new secp256k1.Signature(BigInt(hexlify13(r)), BigInt(hexlify13(s))).addRecoveryBit(
+    const sig = new secp256k1.Signature(BigInt(hexlify14(r)), BigInt(hexlify14(s))).addRecoveryBit(
       recoveryParam
     );
     const publicKey = sig.recoverPublicKey(arrayify15(data)).toRawBytes(false).slice(1);
-    return hexlify13(publicKey);
+    return hexlify14(publicKey);
   }
   /**
    * Recover the address from a signature performed with [`sign`](#sign).
@@ -5931,7 +5968,7 @@ var Signer = class {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? hash(concat3([randomBytes2(32), arrayify15(entropy)])) : randomBytes2(32);
+    return entropy ? hash(concat3([randomBytes3(32), arrayify15(entropy)])) : randomBytes3(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -5941,7 +5978,7 @@ var Signer = class {
    */
   static extendPublicKey(publicKey) {
     const point = secp256k1.ProjectivePoint.fromHex(arrayify15(publicKey));
-    return hexlify13(point.toRawBytes(false).slice(1));
+    return hexlify14(point.toRawBytes(false).slice(1));
   }
 };
 
@@ -5950,14 +5987,14 @@ import { Address as Address5 } from "@fuel-ts/address";
 import {
   bufferFromString,
   keccak256,
-  randomBytes as randomBytes3,
+  randomBytes as randomBytes4,
   scrypt,
   stringFromBuffer,
   decryptJsonWalletData,
   encryptJsonWalletData
 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
-import { hexlify as hexlify14 } from "@fuel-ts/utils";
+import { hexlify as hexlify15 } from "@fuel-ts/utils";
 import { v4 as uuidv4 } from "uuid";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -5973,7 +6010,7 @@ var removeHexPrefix = (hexString) => {
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = bufferFromString(removeHexPrefix(privateKey), "hex");
   const ownerAddress = Address5.fromAddressOrString(address);
-  const salt = randomBytes3(DEFAULT_KEY_SIZE);
+  const salt = randomBytes4(DEFAULT_KEY_SIZE);
   const key = scrypt({
     password: bufferFromString(password),
     salt,
@@ -5982,7 +6019,7 @@ async function encryptKeystoreWallet(privateKey, address, password) {
     r: DEFAULT_KDF_PARAMS_R,
     p: DEFAULT_KDF_PARAMS_P
   });
-  const iv = randomBytes3(DEFAULT_IV_SIZE);
+  const iv = randomBytes4(DEFAULT_IV_SIZE);
   const ciphertext = await encryptJsonWalletData(privateKeyBuffer, key, iv);
   const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
   const macHashUint8Array = keccak256(data);
@@ -6040,7 +6077,7 @@ async function decryptKeystoreWallet(jsonWallet, password) {
     );
   }
   const buffer = await decryptJsonWalletData(ciphertextBuffer, key, ivBuffer);
-  const privateKey = hexlify14(buffer);
+  const privateKey = hexlify15(buffer);
   return privateKey;
 }
 
@@ -6085,7 +6122,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign(hashMessage(message));
-    return hexlify15(signedMessage);
+    return hexlify16(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -6098,7 +6135,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return hexlify15(signature);
+    return hexlify16(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -6131,7 +6168,7 @@ var BaseWalletUnlocked = class extends Account {
     );
   }
   /**
-   * Populates the witness signature for a transaction and sends a call to the network using `provider.call`.
+   * Populates the witness signature for a transaction and sends a call to the network using `provider.dryRun`.
    *
    * @param transactionRequestLike - The transaction request to simulate.
    * @returns A promise that resolves to the CallResult object.
@@ -6141,7 +6178,7 @@ var BaseWalletUnlocked = class extends Account {
     if (estimateTxDependencies) {
       await this.provider.estimateTxDependencies(transactionRequest);
     }
-    return this.provider.call(
+    return this.provider.dryRun(
       await this.populateTransactionWitnessesSignature(transactionRequest),
       {
         utxoValidation: true,
@@ -6169,13 +6206,13 @@ import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
 import { bn as bn20, toBytes as toBytes2, toHex } from "@fuel-ts/math";
-import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
+import { arrayify as arrayify18, hexlify as hexlify18, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
-import { randomBytes as randomBytes4, pbkdf2, computeHmac } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes5, pbkdf2, computeHmac } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
-import { arrayify as arrayify17, hexlify as hexlify16, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
+import { arrayify as arrayify17, hexlify as hexlify17, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -8375,7 +8412,7 @@ var Mnemonic = class {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return hexlify16(mnemonicWordsToEntropy(words, wordlist));
+    return hexlify17(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -8500,7 +8537,7 @@ var Mnemonic = class {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? sha2563(concat4([randomBytes4(size), arrayify17(extraEntropy)])) : randomBytes4(size);
+    const entropy = extraEntropy ? sha2563(concat4([randomBytes5(size), arrayify17(extraEntropy)])) : randomBytes5(size);
     return Mnemonic.entropyToMnemonic(entropy);
   }
 };
@@ -8508,10 +8545,10 @@ var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = hexlify17("0x0488ade4");
-var MainnetPUB = hexlify17("0x0488b21e");
-var TestnetPRV2 = hexlify17("0x04358394");
-var TestnetPUB = hexlify17("0x043587cf");
+var MainnetPRV2 = hexlify18("0x0488ade4");
+var MainnetPUB = hexlify18("0x0488b21e");
+var TestnetPRV2 = hexlify18("0x04358394");
+var TestnetPUB = hexlify18("0x043587cf");
 function base58check(data) {
   return encodeBase582(concat5([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
 }
@@ -8522,11 +8559,11 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
   return testnet ? TestnetPRV2 : MainnetPRV2;
 }
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes(hexlify17(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes(hexlify18(extendedKey.slice(0, 4)));
 }
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    hexlify17(extendedKey.slice(0, 4))
+    hexlify18(extendedKey.slice(0, 4))
   );
 }
 function parsePath(path, depth = 0) {
@@ -8544,8 +8581,8 @@ function parsePath(path, depth = 0) {
 var HDWallet = class {
   depth = 0;
   index = 0;
-  fingerprint = hexlify17("0x00000000");
-  parentFingerprint = hexlify17("0x00000000");
+  fingerprint = hexlify18("0x00000000");
+  parentFingerprint = hexlify18("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -8557,8 +8594,8 @@ var HDWallet = class {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = hexlify17(signer.compressedPublicKey);
-      this.privateKey = hexlify17(config.privateKey);
+      this.publicKey = hexlify18(signer.compressedPublicKey);
+      this.privateKey = hexlify18(config.privateKey);
     } else {
       if (!config.publicKey) {
         throw new FuelError19(
@@ -8566,7 +8603,7 @@ var HDWallet = class {
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = hexlify17(config.publicKey);
+      this.publicKey = hexlify18(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
     this.fingerprint = dataSlice2(ripemd160(sha2564(this.publicKey)), 0, 4);
@@ -8615,7 +8652,7 @@ var HDWallet = class {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer(hexlify17(IL));
+    const signer = new Signer(hexlify18(IL));
     const Ki = signer.addPoint(publicKey);
     return new HDWallet({
       publicKey: Ki,
@@ -8650,7 +8687,7 @@ var HDWallet = class {
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = hexlify17(Uint8Array.from([this.depth]));
+    const depth = hexlify18(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
     const index = toHex(this.index, 4);
     const chainCode = this.chainCode;
@@ -8672,7 +8709,7 @@ var HDWallet = class {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = hexlify17(toBytes2(decodeBase58(extendedKey)));
+    const decoded = hexlify18(toBytes2(decodeBase58(extendedKey)));
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
@@ -8682,9 +8719,9 @@ var HDWallet = class {
       throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = hexlify17(bytes.slice(5, 9));
-    const index = parseInt(hexlify17(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = hexlify17(bytes.slice(13, 45));
+    const parentFingerprint = hexlify18(bytes.slice(5, 9));
+    const index = parseInt(hexlify18(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = hexlify18(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new FuelError19(
@@ -9288,17 +9325,17 @@ var StorageAbstract = class {
 import { Interface as Interface4 } from "@fuel-ts/abi-coder";
 import { Address as Address9 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode24, FuelError as FuelError24 } from "@fuel-ts/errors";
-import { arrayify as arrayify20, hexlify as hexlify19 } from "@fuel-ts/utils";
+import { arrayify as arrayify20, hexlify as hexlify20 } from "@fuel-ts/utils";
 
 // src/predicate/utils/getPredicateRoot.ts
 import { hash as hash2 } from "@fuel-ts/hasher";
 import { calcRoot } from "@fuel-ts/merkle";
-import { chunkAndPadBytes, hexlify as hexlify18, concat as concat6, arrayify as arrayify19 } from "@fuel-ts/utils";
+import { chunkAndPadBytes, hexlify as hexlify19, concat as concat6, arrayify as arrayify19 } from "@fuel-ts/utils";
 var getPredicateRoot = (bytecode) => {
   const chunkSize = 16 * 1024;
   const bytes = arrayify19(bytecode);
   const chunks = chunkAndPadBytes(bytes, chunkSize);
-  const codeRoot = calcRoot(chunks.map((c) => hexlify18(c)));
+  const codeRoot = calcRoot(chunks.map((c) => hexlify19(c)));
   const predicateRoot = hash2(concat6(["0x4655454C", codeRoot]));
   return predicateRoot;
 };
@@ -9351,8 +9388,8 @@ var Predicate = class extends Account {
     }
     request.inputs.filter(isRequestInputResource).forEach((input) => {
       if (isRequestInputResourceFromOwner(input, this.address)) {
-        input.predicate = hexlify19(this.bytes);
-        input.predicateData = hexlify19(this.getPredicateData());
+        input.predicate = hexlify20(this.bytes);
+        input.predicateData = hexlify20(this.getPredicateData());
         input.witnessIndex = 0;
       }
     });
@@ -9432,8 +9469,21 @@ var Predicate = class extends Account {
     );
     return resources.map((resource) => ({
       ...resource,
-      predicate: hexlify19(this.bytes),
-      predicateData: hexlify19(this.getPredicateData())
+      predicate: hexlify20(this.bytes),
+      predicateData: hexlify20(this.getPredicateData())
+    }));
+  }
+  /**
+   * Generates an array of fake resources based on the provided coins.
+   *
+   * @param coins - An array of `FakeResources` objects representing the coins.
+   * @returns An array of `Resource` objects with generated properties.
+   */
+  generateFakeResources(coins) {
+    return super.generateFakeResources(coins).map((coin) => ({
+      ...coin,
+      predicate: hexlify20(this.bytes),
+      predicateData: hexlify20(this.getPredicateData())
     }));
   }
   /**
@@ -10297,7 +10347,6 @@ export {
   resolveGasDependentCosts,
   resolveIconPaths,
   returnZeroScript,
-  sleep,
   transactionRequestify,
   urlJoin,
   withTimeout,