feat: upgrade to fuel-core 0.10.1

.changeset/tidy-bulldogs-tap.md

@@ -0,0 +1,11 @@
+---
+"@fuel-ts/abi-coder": minor
+"@fuel-ts/contract": minor
+"@fuel-ts/providers": minor
+"@fuel-ts/testcases": minor
+"@fuel-ts/transactions": minor
+"@fuel-ts/wallet": minor
+"@fuel-ts/wallet-manager": minor
+---
+
+Upgrade compatibility to fuel-core v0.10.1

packages/contract/src/__test__/call-test-contract/call-test-contract.test.ts

@@ -1,55 +1,24 @@
-import type { Interface, JsonAbi } from '@fuel-ts/abi-coder';
 import { NativeAssetId } from '@fuel-ts/constants';
-import { Provider } from '@fuel-ts/providers';
-import type { Wallet } from '@fuel-ts/wallet';
-import { TestUtils } from '@fuel-ts/wallet';
 import { readFileSync } from 'fs';
 import { join } from 'path';
 
-import type Contract from '../../contracts/contract';
-import ContractFactory from '../../contracts/contract-factory';
+import { createSetupConfig } from '../test-utils';
 
 import abiJSON from './out/debug/call-test-flat-abi.json';
 
 const contractBytecode = readFileSync(join(__dirname, './out/debug/call-test.bin'));
 
-let contractInstance: Contract;
-const deployContract = async (factory: ContractFactory, useCache: boolean = true) => {
-  if (contractInstance && useCache) return contractInstance;
-  if (!useCache) {
-    return factory.deployContract({
-      gasPrice: 1,
-      bytePrice: 1,
-    });
-  }
-  contractInstance = await factory.deployContract();
-  return contractInstance;
-};
-
-let walletInstance: Wallet;
-const createWallet = async () => {
-  if (walletInstance) return walletInstance;
-  const provider = new Provider('http://127.0.0.1:4000/graphql');
-  walletInstance = await TestUtils.generateTestWallet(provider, [
-    [5_000_000, NativeAssetId],
-    [5_000_000, '0x0101010101010101010101010101010101010101010101010101010101010101'],
-  ]);
-  return walletInstance;
-};
-
-export const setup = async (abi: JsonAbi | Interface = abiJSON, useCache: boolean = true) => {
-  // Create wallet
-  const wallet = await createWallet();
-  const factory = new ContractFactory(contractBytecode, abi, wallet);
-  const contract = await deployContract(factory, useCache);
-  return contract;
-};
+const setupContract = createSetupConfig({
+  contractBytecode,
+  abi: abiJSON,
+  cache: true,
+});
 
 const U64_MAX = 2n ** 64n - 1n;
 
 describe('CallTestContract', () => {
   it.each([0n, 1337n, U64_MAX - 1n])('can call a contract with u64 (%p)', async (num) => {
-    const contract = await setup();
+    const contract = await setupContract();
     const { value } = await contract.functions.foo(num).call<bigint>();
     expect(value).toEqual(num + 1n);
   });
@@ -62,14 +31,14 @@ describe('CallTestContract', () => {
     [{ a: false, b: U64_MAX - 1n }],
     [{ a: true, b: U64_MAX - 1n }],
   ])('can call a contract with structs (%p)', async (struct) => {
-    const contract = await setup();
+    const contract = await setupContract();
     const { value } = await contract.functions.boo(struct).call();
     expect(value.a).toEqual(!struct.a);
     expect(value.b).toEqual(struct.b + 1n);
   });
 
   it('can call a function with empty arguments', async () => {
-    const contract = await setup();
+    const contract = await setupContract();
 
     const { value: value0 } = await contract.functions.barfoo(0).call();
     expect(value0).toEqual(63n);
@@ -79,25 +48,29 @@ describe('CallTestContract', () => {
   });
 
   it('function with empty return output configured should resolve undefined', async () => {
-    const contract = await setup([
-      {
-        type: 'function',
-        name: 'return_void',
-        outputs: [{ type: '()', name: 'foo' }],
-      },
-    ]);
+    const contract = await setupContract({
+      abi: [
+        {
+          type: 'function',
+          name: 'return_void',
+          outputs: [{ type: '()', name: 'foo' }],
+        },
+      ],
+    });
 
     const { value } = await contract.functions.return_void().call();
     expect(value).toEqual(undefined);
   });
 
   it('function with empty return should resolve undefined', async () => {
-    const contract = await setup([
-      {
-        type: 'function',
-        name: 'return_void',
-      },
-    ]);
+    const contract = await setupContract({
+      abi: [
+        {
+          type: 'function',
+          name: 'return_void',
+        },
+      ],
+    });
 
     // Call method with no params but with no result and no value on config
     const { value } = await await contract.functions.return_void().call();
@@ -172,7 +145,7 @@ describe('CallTestContract', () => {
   ])(
     `Test call with multiple arguments and different types -> %s`,
     async (method, { values, expected }) => {
-      const contract = await setup();
+      const contract = await setupContract();
 
       const { value } = await contract.functions[method](...values).call();
 
@@ -181,17 +154,19 @@ describe('CallTestContract', () => {
   );
 
   it('Forward amount value on contract call', async () => {
-    const contract = await setup([
-      {
-        type: 'function',
-        name: 'return_context_amount',
-        outputs: [
-          {
-            type: 'u64',
-          },
-        ],
-      },
-    ]);
+    const contract = await setupContract({
+      abi: [
+        {
+          type: 'function',
+          name: 'return_context_amount',
+          outputs: [
+            {
+              type: 'u64',
+            },
+          ],
+        },
+      ],
+    });
     const { value } = await contract.functions
       .return_context_amount()
       .callParams({
@@ -202,17 +177,19 @@ describe('CallTestContract', () => {
   });
 
   it('Forward asset_id on contract call', async () => {
-    const contract = await setup([
-      {
-        type: 'function',
-        name: 'return_context_asset',
-        outputs: [
-          {
-            type: 'b256',
-          },
-        ],
-      },
-    ]);
+    const contract = await setupContract({
+      abi: [
+        {
+          type: 'function',
+          name: 'return_context_amount',
+          outputs: [
+            {
+              type: 'u64',
+            },
+          ],
+        },
+      ],
+    });
 
     const assetId = '0x0101010101010101010101010101010101010101010101010101010101010101';
     const { value } = await contract.functions
@@ -225,17 +202,19 @@ describe('CallTestContract', () => {
   });
 
   it('Forward asset_id on contract simulate call', async () => {
-    const contract = await setup([
-      {
-        type: 'function',
-        name: 'return_context_asset',
-        outputs: [
-          {
-            type: 'b256',
-          },
-        ],
-      },
-    ]);
+    const contract = await setupContract({
+      abi: [
+        {
+          type: 'function',
+          name: 'return_context_asset',
+          outputs: [
+            {
+              type: 'b256',
+            },
+          ],
+        },
+      ],
+    });
 
     const assetId = '0x0101010101010101010101010101010101010101010101010101010101010101';
     const { value } = await contract.functions
@@ -248,7 +227,7 @@ describe('CallTestContract', () => {
   });
 
   it('can make multiple calls', async () => {
-    const contract = await setup();
+    const contract = await setupContract();
 
     const num = 1337n;
     const numC = 10n;