WIP: testing networks

.changeset/strange-glasses-act.md

@@ -0,0 +1,8 @@
+---
+"@internal/fuel-core": patch
+"@fuel-ts/versions": patch
+"@fuel-ts/account": patch
+"fuels": patch
+---
+
+chore: update `fuel-core` to `0.38.0`

.env.example

@@ -1,3 +1,7 @@
 DEVNET_WALLET_PVT_KEY=
 TESTNET_WALLET_PVT_KEY=
-PUBLISHED_NPM_TAG=
+PUBLISHED_NPM_TAG=
+
+
+TESTING_NETWORK_URL=
+TESTING_NETWORK_PVT_KEY=

apps/docs-snippets/src/guide/cookbook/resubmitting-failed-transactions.test.ts

@@ -71,7 +71,7 @@ describe('Resubmitting Failed Transactions', () => {
         }
       }
       // #endregion resubmitting-failed-transactions-3
-    }).rejects.toThrow('Transaction is not inserted. UTXO does not exist: 0x');
+    }).rejects.toThrowError(/Transaction input validation failed: UTXO \(id: .*\) does not exist/);
 
     await expect(
       (async () => {

apps/docs-snippets/src/guide/provider/querying-the-chain.test.ts

@@ -152,16 +152,16 @@ describe('querying the chain', () => {
 
     const provider = await Provider.create(FUEL_NETWORK_URL);
 
-    const blockToProduce = 3;
+    // const blockToProduce = 3;
 
-    // Force-producing some blocks to make sure that 10 blocks exist
-    await provider.produceBlocks(blockToProduce);
+    // // Force-producing some blocks to make sure that 10 blocks exist
+    // await provider.produceBlocks(blockToProduce);
 
     const { blocks } = await provider.getBlocks({
-      last: blockToProduce,
+      last: 10,
     });
     // #endregion Provider-get-blocks
-    expect(blocks.length).toBe(blockToProduce);
+    expect(blocks.length).toBe(10);
   });
 
   it('can getMessageByNonce', async () => {

internal/fuel-core/VERSION

@@ -1 +1 @@
-0.37.1
+0.38.0

packages/account/src/providers/provider.test.ts

@@ -298,7 +298,7 @@
 
     const version = await provider.getVersion();
 
-    expect(version).toEqual('0.37.1');
+    expect(version).toEqual(versions.FUEL_CORE);
   });
 
   it('can call()', async () => {
@@ -925,59 +925,65 @@
     });
   });
 
-  it('can getBlocks', async () => {
+  it.only('can getBlocks', async () => {
     using launched = await setupTestProviderAndWallets();
     const blocksLenght = 5;
     const { provider } = launched;
+
+    // console.log(provider.url);
     // Force-producing some blocks to make sure that blocksLenght blocks exist
-    await provider.produceBlocks(blocksLenght);
+    // await provider.produceBlocks(blocksLenght);
     const { blocks } = await provider.getBlocks({
-      last: 5,
-    });
-    expect(blocks.length).toBe(blocksLenght);
-    blocks.forEach((block) => {
-      expect(block).toStrictEqual({
-        id: expect.any(String),
-        height: expect.any(BN),
-        time: expect.any(String),
-        header: {
-          applicationHash: expect.any(String),
-          daHeight: expect.any(BN),
-          eventInboxRoot: expect.any(String),
-          messageOutboxRoot: expect.any(String),
-          prevRoot: expect.any(String),
-          stateTransitionBytecodeVersion: expect.any(String),
-          transactionsCount: expect.any(String),
-          transactionsRoot: expect.any(String),
-        },
-        transactionIds: expect.any(Array<string>),
-      });
-    });
-  });
-
-  it('can getBlockWithTransactions', async () => {
+      last: 47,
+    });
+
+    console.log(blocks);
+    console.log(blocks.length);
+    // expect(blocks.length).toBe(blocksLenght);
+    // blocks.forEach((block) => {
+    //   expect(block).toStrictEqual({
+    //     id: expect.any(String),
+    //     height: expect.any(BN),
+    //     time: expect.any(String),
+    //     header: {
+    //       applicationHash: expect.any(String),
+    //       daHeight: expect.any(BN),
+    //       eventInboxRoot: expect.any(String),
+    //       messageOutboxRoot: expect.any(String),
+    //       prevRoot: expect.any(String),
+    //       stateTransitionBytecodeVersion: expect.any(String),
+    //       transactionsCount: expect.any(String),
+    //       transactionsRoot: expect.any(String),
+    //     },
+    //     transactionIds: expect.any(Array<string>),
+    //   });
+    // });
+  });
+
+  it.only('can getBlockWithTransactions', async () => {
     using launched = await setupTestProviderAndWallets();
     const { provider } = launched;
-    await provider.produceBlocks(1);
-    const block = await provider.getBlockWithTransactions('latest');
-    const { transactions } = await provider.getTransactions({ first: 100 });
-    expect(block).toStrictEqual({
-      id: expect.any(String),
-      height: expect.any(BN),
-      time: expect.any(String),
-      header: {
-        applicationHash: expect.any(String),
-        daHeight: expect.any(BN),
-        eventInboxRoot: expect.any(String),
-        messageOutboxRoot: expect.any(String),
-        prevRoot: expect.any(String),
-        stateTransitionBytecodeVersion: expect.any(String),
-        transactionsCount: expect.any(String),
-        transactionsRoot: expect.any(String),
-      },
-      transactionIds: expect.any(Array<string>),
-      transactions,
-    });
+    // await provider.produceBlocks(1);
+    // const block = await provider.getBlockWithTransactions('latest');
+    const { transactions } = await provider.getTransactions({ last: 164 });
+    console.log('length', transactions.length);
+    // expect(block).toStrictEqual({
+    //   id: expect.any(String),
+    //   height: expect.any(BN),
+    //   time: expect.any(String),
+    //   header: {
+    //     applicationHash: expect.any(String),
+    //     daHeight: expect.any(BN),
+    //     eventInboxRoot: expect.any(String),
+    //     messageOutboxRoot: expect.any(String),
+    //     prevRoot: expect.any(String),
+    //     stateTransitionBytecodeVersion: expect.any(String),
+    //     transactionsCount: expect.any(String),
+    //     transactionsRoot: expect.any(String),
+    //   },
+    //   transactionIds: expect.any(Array<string>),
+    //   transactions,
+    // });
   });
 
   it('can getMessageProof with all data', async () => {

packages/account/src/test-utils/launchNode.ts

@@ -185,6 +185,7 @@ export const launchNode = async ({
         ['--ip', ipToUse],
         ['--port', portToUse],
         useInMemoryDb ? ['--db-type', 'in-memory'] : ['--db-path', tempDir],
+        ['--tx-ttl-check-interval', '1s'],
         ['--min-gas-price', minGasPrice],
         poaInstant ? ['--poa-instant', 'true'] : [],
         ['--native-executor-version', nativeExecutorVersion],

packages/account/src/test-utils/setup-test-provider-and-wallets.ts

@@ -1,13 +1,14 @@
 import { defaultSnapshotConfigs, type SnapshotConfigs } from '@fuel-ts/utils';
+import { DEVNET_NETWORK_URL, TESTNET_NETWORK_URL } from '@internal/utils';
 import { mergeDeepRight } from 'ramda';
 import type { PartialDeep } from 'type-fest';
 
 import type { ProviderOptions } from '../providers';
 import { Provider } from '../providers';
-import type { WalletUnlocked } from '../wallet';
+import { Wallet, type WalletUnlocked } from '../wallet';
 
 import type { LaunchNodeOptions } from './launchNode';
 import { launchNode } from './launchNode';
 import { TestAssetId } from './test-asset-id';
 import type { WalletsConfigOptions } from './wallet-config';
 import { WalletsConfig } from './wallet-config';
@@ -51,9 +52,9 @@
  */
 export async function setupTestProviderAndWallets({
   walletsConfig: walletsConfigOptions = {},
   providerOptions,
   nodeOptions = {},
   launchNodeServerPort = process.env.LAUNCH_NODE_SERVER_PORT || undefined,
 }: Partial<LaunchCustomProviderAndGetWalletsOptions> = {}): Promise<SetupTestProviderAndWalletsReturn> {
   // @ts-expect-error this is a polyfill (see https://devblogs.microsoft.com/typescript/announcing-typescript-5-2/#using-declarations-and-explicit-resource-management)
   Symbol.dispose ??= Symbol('Symbol.dispose');
@@ -66,47 +67,22 @@
     }
   );
 
-  const launchNodeOptions: LaunchNodeOptions = {
-    loggingEnabled: false,
-    ...nodeOptions,
-    snapshotConfig: mergeDeepRight(
-      defaultSnapshotConfigs,
-      walletsConfig.apply(nodeOptions?.snapshotConfig)
-    ),
-    port: nodeOptions.port || '0',
-  };
-
-  let cleanup: () => void;
-  let url: string;
-  if (launchNodeServerPort) {
-    const serverUrl = `http://localhost:${launchNodeServerPort}`;
-    url = await (
-      await fetch(serverUrl, { method: 'POST', body: JSON.stringify(launchNodeOptions) })
-    ).text();
-
-    cleanup = () => {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      fetch(`${serverUrl}/cleanup/${url}`);
-    };
-  } else {
-    const settings = await launchNode(launchNodeOptions);
-    url = settings.url;
-    cleanup = settings.cleanup;
-  }
-
-  let provider: Provider;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const provider = await Provider.create(process.env.TESTING_NETWORK_URL!);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const wallet = Wallet.fromPrivateKey(process.env.TESTING_NETWORK_PVT_KEY!, provider);
 
-  try {
-    provider = await Provider.create(url, providerOptions);
-  } catch (err) {
-    cleanup();
-    throw err;
-  }
+  // console.log('Address', wallet.address.toB256());
+  // console.log('Base asset id', provider.getBaseAssetId());
+  // console.log(
+  //   (await wallet.getBalances()).balances.map((b) => ({
+  //     amount: b.amount.toString(),
+  //     assetId: b.assetId,
+  //   }))
+  // );
 
-  const wallets = walletsConfig.wallets;
-  wallets.forEach((wallet) => {
-    wallet.connect(provider);
-  });
+  const wallets = [wallet, wallet, wallet, wallet, wallet];
+  const cleanup = () => {};
 
   return {
     provider,

packages/contract/src/test-utils/launch-test-node.ts

@@ -1,4 +1,6 @@
-import type { Account, WalletUnlocked } from '@fuel-ts/account';
+import { Provider, Wallet } from '@fuel-ts/account';
+import type { WalletUnlocked, Account } from '@fuel-ts/account';
+import { DEVNET_NETWORK_URL, TESTNET_NETWORK_URL } from '@fuel-ts/account/configs';
 import { setupTestProviderAndWallets } from '@fuel-ts/account/test-utils';
 import type {
   LaunchCustomProviderAndGetWalletsOptions,
@@ -129,15 +131,27 @@ export async function launchTestNode<const TFactories extends DeployContractConf
 }: Partial<LaunchTestNodeOptions<TFactories>> = {}): Promise<LaunchTestNodeReturn<TFactories>> {
   const snapshotConfig = getChainSnapshot(nodeOptions);
   const args = getFuelCoreArgs(nodeOptions);
-  const { provider, wallets, cleanup } = await setupTestProviderAndWallets({
-    walletsConfig,
-    providerOptions,
-    nodeOptions: {
-      ...nodeOptions,
-      snapshotConfig,
-      args,
-    },
-  });
+  // const { provider, wallets, cleanup } = await setupTestProviderAndWallets({
+  //   walletsConfig,
+  //   providerOptions,
+  //   nodeOptions: {
+  //     ...nodeOptions,
+  //     snapshotConfig,
+  //     args,
+  //   },
+  // });
+
+  // @TODO change network + private key
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const provider = await Provider.create(process.env.TESTING_NETWORK_URL!);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const wallet = Wallet.fromPrivateKey(process.env.TESTING_NETWORK_PVT_KEY!, provider);
+
+  console.log('address', wallet.address.toB256());
+  console.log((await wallet.getBalances()).balances.map((b) => b.amount.toString()));
+  const wallets = [wallet, wallet, wallet, wallet, wallet, wallet, wallet, wallet];
+  const cleanup = () => {};
 
   const contracts: TContracts<TFactories> = [] as TContracts<TFactories>;
   const configs = contractsConfigs ?? [];