docs: add further snippets with new infrastructure

.eslintignore

@@ -14,6 +14,7 @@ apps/demo-react-vite
 apps/create-fuels-counter-guide
 apps/docs-snippets2/src/typegend
 apps/docs-snippets2/src/**/*.wrapped.ts
+apps/docs-snippets2/src/**/*.test.ts
 
 packages/fuels/src/cli/commands/deploy/proxy
 packages/fuels/test/fixtures/project

apps/docs-snippets2/scripts/test-template.ts

@@ -8,10 +8,7 @@ afterAll(() => {
   console = { ...consoleBkp };
 });
 
-/**
- * @group node
- * @group browser
- */
+// %TEST_ENVIRONMENT%
 test('%NAME%', async () => {
   // TEST NODE LAUNCHER ———>>>
   // %NODE_LAUNCHER%

apps/docs-snippets2/scripts/wrap-snippets.ts

@@ -12,6 +12,20 @@ const wrapperFnContents = readFileSync(wrapperFnFilepath, 'utf-8');
 export const wrapSnippet = (filepath: string) => {
   const snippetContents = readFileSync(filepath, 'utf8');
 
+  /**
+   * Test environment
+   */
+  let testEnvironments = '';
+
+  // Check if the filepath includes '.node' or '.browser'
+  if (filepath.includes('.node')) {
+    testEnvironments = '/**\n * @group node\n */';
+  } else if (filepath.includes('.browser')) {
+    testEnvironments = '/**\n * @group browser\n */';
+  } else {
+    testEnvironments = '/**\n * @group node\n * @group browser\n */';
+  }
+
   /*
     Filter all imports from file.
   */
@@ -74,6 +88,7 @@ export const wrapSnippet = (filepath: string) => {
   const wrappedSnippet =
     // eslintDisableRule +
     wrapperFnContents
+      .replace('// %TEST_ENVIRONMENT%', testEnvironments)
       .replace('%IMPORTS%', imports)
       .replace('%NAME%', basename(filepath))
       .replace('// %SNIPPET%', indented)

apps/docs-snippets2/src/create-fuels/decrement-counter.ts

@@ -0,0 +1,52 @@
+// #region full
+import { Wallet, Provider } from 'fuels';
+
+import { LOCAL_NETWORK_URL, WALLET_PVT_KEY } from '../env';
+import { CounterFactory } from '../typegend/contracts';
+
+// Let's create our provider from the network URL.
+const provider = await Provider.create(LOCAL_NETWORK_URL);
+// Let's create our wallet from the private key.
+const wallet = Wallet.fromPrivateKey(WALLET_PVT_KEY, provider);
+
+// Then we can deploy the contract.
+const { waitForResult } = await CounterFactory.deploy(wallet);
+const { contract } = await waitForResult();
+
+// Lets setup some values to use in our example.
+const initialCount = 0;
+const incrementedValue = 5;
+const decrementedValue = 2;
+
+// We can now call the contract functions and test the results. Lets assert the initial value of the counter.
+const { waitForResult: getCountWaitForResult } = await contract.functions.get_count().call();
+const { value: initialGetCountValue } = await getCountWaitForResult();
+console.assert(
+  initialGetCountValue.toNumber() === initialCount,
+  'Initial value should be equal to the initial count.'
+);
+
+// Next we'll increment the counter, so that we can decrement it.
+const { waitForResult: incWaitForResult } = await contract.functions.increment_count(5).call();
+const { value: incValue } = await incWaitForResult();
+console.assert(
+  incValue.toNumber() === incrementedValue,
+  'Incremented value should be equal to the incremented value.'
+);
+
+// Next, we'll decrement the counter by 3 and assert the new value.
+const { waitForResult: decWaitForResult } = await contract.functions.decrement_count(3).call();
+const { value: decValue } = await decWaitForResult();
+console.assert(
+  decValue.toNumber() === decrementedValue,
+  'Decremented value should be equal to the decremented value.'
+);
+
+// Finally, we'll test the get count function again to ensure parity.
+const { waitForResult: finalWaitForResult } = await contract.functions.get_count().call();
+const { value: finalValue } = await finalWaitForResult();
+console.assert(
+  finalValue.toNumber() === decrementedValue,
+  'Final value should be equal to the decremented value.'
+);
+// #endregion full

apps/docs-snippets2/src/encoding/encode-and-decode.ts

@@ -0,0 +1,115 @@
+// #region full
+import type { JsonAbi, TransactionResultReturnDataReceipt } from 'fuels';
+import {
+  buildFunctionResult,
+  ReceiptType,
+  arrayify,
+  Script,
+  Interface,
+  Provider,
+  Wallet,
+} from 'fuels';
+
+// #region encode-and-decode-3
+import { LOCAL_NETWORK_URL, WALLET_PVT_KEY } from '../env';
+import { ScriptSum } from '../typegend';
+
+const provider = await Provider.create(LOCAL_NETWORK_URL);
+const wallet = Wallet.fromPrivateKey(WALLET_PVT_KEY, provider);
+
+// First we need to build out the transaction via the script that we want to encode.
+// For that we'll need the ABI and the bytecode of the script
+const abi: JsonAbi = ScriptSum.abi;
+const bytecode = ScriptSum.bytecode;
+
+// Create the invocation scope for the script call, passing the initial
+// value for the configurable constant
+const script = new Script(bytecode, abi, wallet);
+const initialValue = 10;
+script.setConfigurableConstants({ AMOUNT: initialValue });
+const invocationScope = script.functions.main(0);
+
+// Create the transaction request, this can be picked off the invocation
+// scope so the script bytecode is preset on the transaction
+const request = await invocationScope.getTransactionRequest();
+// #endregion encode-and-decode-3
+
+// #region encode-and-decode-4
+
+// Now we can encode the argument we want to pass to the function. The argument is required
+// as a function parameter for all abi functions and we can extract it from the ABI itself
+const argument = abi.functions
+  .find((f) => f.name === 'main')
+  ?.inputs.find((i) => i.name === 'inputted_amount')?.concreteTypeId as string;
+
+// The `Interface` class (imported from `fuels`) is the entry point for encoding and decoding all things abi-related.
+// We will use its `encodeType` method and create the encoding required for
+// a u32 which takes 4 bytes up of property space.
+
+const abiInterface = new Interface(abi);
+const argumentToAdd = 10;
+const encodedArguments = abiInterface.encodeType(argument, [argumentToAdd]);
+// Therefore the value of 10 will be encoded to:
+// Uint8Array([0, 0, 0, 10]
+
+// The encoded value can now be set on the transaction via the script data property
+request.scriptData = encodedArguments;
+
+// Now we can build out the rest of the transaction and then fund it
+const txCost = await wallet.getTransactionCost(request);
+request.maxFee = txCost.maxFee;
+request.gasLimit = txCost.gasUsed;
+await wallet.fund(request, txCost);
+
+// Finally, submit the built transaction
+const response = await wallet.sendTransaction(request);
+await response.waitForResult();
+// #endregion encode-and-decode-4
+
+// #region encode-and-decode-5
+
+// Get result of the transaction, including the contract call result. For this we'll need
+// the previously created invocation scope, the transaction response and the script
+const invocationResult = await buildFunctionResult({
+  funcScope: invocationScope,
+  isMultiCall: false,
+  program: script,
+  transactionResponse: response,
+});
+
+// The decoded value can be destructured from the `FunctionInvocationResult`
+const { value } = invocationResult;
+
+// Or we can decode the returned bytes ourselves, by retrieving the return data
+// receipt that contains the returned bytes. We can get this by filtering on
+// the returned receipt types
+const returnDataReceipt = invocationResult.transactionResult.receipts.find(
+  (r) => r.type === ReceiptType.ReturnData
+) as TransactionResultReturnDataReceipt;
+
+// The data is in hex format so it makes sense to use arrayify so that the data
+// is more human readable
+const returnData = arrayify(returnDataReceipt.data);
+// returnData = new Uint8Array([0, 0, 0, 20]
+
+// And now we can decode the returned bytes in a similar fashion to how they were
+// encoded, via the `Interface`
+const [decodedReturnData] = abiInterface.decodeType(argument, returnData);
+// 20
+
+const totalValue = argumentToAdd + initialValue;
+// #endregion encode-and-decode-5
+// #endregion full
+console.assert(value === totalValue, 'Value should be equal to the total value.');
+console.assert(
+  decodedReturnData === totalValue,
+  'Decoded return data should be equal to the total value.'
+);
+console.assert(
+  encodedArguments.toString() === new Uint8Array([0, 0, 0, 10]).toString(),
+  'Encoded arguments should be equal to the total value.'
+);
+console.assert(
+  returnData.toString() === new Uint8Array([0, 0, 0, 20]).toString(),
+  'Return data should be equal to the total value.'
+);

apps/docs-snippets2/src/encoding/working-with-bytes.ts

@@ -0,0 +1,154 @@
+// #region full
+import { randomBytes } from 'crypto';
+import {
+  ArrayCoder,
+  B256Coder,
+  B512Coder,
+  BigNumberCoder,
+  BooleanCoder,
+  EnumCoder,
+  NumberCoder,
+  RawSliceCoder,
+  StdStringCoder,
+  StringCoder,
+  StructCoder,
+  TupleCoder,
+  VecCoder,
+  hexlify,
+} from 'fuels';
+
+// #region working-with-bytes-1
+const u8Coder = new NumberCoder('u8');
+const encodedU8 = u8Coder.encode(255);
+console.assert(
+  encodedU8.toString() === new Uint8Array([255]).toString(),
+  'Encoded U8 should be equal to 255'
+);
+
+const u16Coder = new NumberCoder('u16');
+const encodedU16 = u16Coder.encode(255);
+console.assert(
+  encodedU16.toString() === new Uint8Array([0, 255]).toString(),
+  'Encoded U16 should be equal to 255'
+);
+
+const u32Coder = new NumberCoder('u32');
+const encodedU32 = u32Coder.encode(255);
+
+console.assert(
+  encodedU32.toString() === new Uint8Array([0, 0, 0, 255]).toString(),
+  'Encoded U32 should be equal to 255'
+);
+
+const u64Coder = new BigNumberCoder('u64');
+const encodedU64 = u64Coder.encode(255);
+console.assert(
+  encodedU64.toString() === new Uint8Array([0, 0, 0, 0, 0, 0, 0, 255]).toString(),
+  'Encoded U64 should be equal to 255'
+);
+
+const u256Coder = new BigNumberCoder('u256');
+const encodedU256 = u256Coder.encode(255);
+console.assert(
+  encodedU256.toString() ===
+    new Uint8Array([
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      255,
+    ]).toString(),
+  'Encoded U256 should be equal to 255'
+);
+// #endregion working-with-bytes-1
+
+// #region working-with-bytes-2
+const booleanCoder = new BooleanCoder();
+const encodedTrue = booleanCoder.encode(true);
+console.assert(
+  encodedTrue.toString() === new Uint8Array([1]).toString(),
+  'Encoded True should be equal to 1'
+);
+
+const encodedFalse = booleanCoder.encode(false);
+console.assert(
+  encodedFalse.toString() === new Uint8Array([0]).toString(),
+  'Encoded False should be equal to 0'
+);
+
+// #endregion working-with-bytes-2
+
+// #region working-with-bytes-3
+const stringCoder = new StringCoder(5);
+const encoded = stringCoder.encode('hello');
+// #endregion working-with-bytes-3
+
+console.assert(
+  encoded.toString() === new Uint8Array([104, 101, 108, 108, 111]).toString(),
+  'Encoded should be equal to hello'
+);
+
+// #region working-with-bytes-4
+const b256Coder = new B256Coder();
+const encodedB256 = b256Coder.encode(hexlify(randomBytes(32)));
+console.assert(encodedB256.length === 32, 'Encoded B256 should be equal to 32');
+
+const b512Coder = new B512Coder();
+const encodedB512 = b512Coder.encode(hexlify(randomBytes(64)));
+console.assert(encodedB512.length === 64, 'Encoded B512 should be equal to 64');
+// #endregion working-with-bytes-4
+
+// #region working-with-bytes-5
+const tupleCoder = new TupleCoder([new NumberCoder('u8'), new NumberCoder('u16')]);
+const encodedTuple = tupleCoder.encode([255, 255]);
+console.assert(
+  encodedTuple.toString() === new Uint8Array([255, 0, 255]).toString(),
+  'Encoded Tuple should be equal to [255, 0, 255]'
+);
+
+const structCoder = new StructCoder('struct', {
+  a: new NumberCoder('u8'),
+  b: new NumberCoder('u16'),
+});
+const encodedStruct = structCoder.encode({ a: 255, b: 255 });
+console.assert(
+  encodedStruct.toString() === new Uint8Array([255, 0, 255]).toString(),
+  'Encoded Struct should be equal to [255, 0, 255]'
+);
+
+const arrayCoder = new ArrayCoder(new NumberCoder('u8'), 4);
+const encodedArray = arrayCoder.encode([255, 0, 255, 0]);
+console.assert(
+  encodedArray.toString() === new Uint8Array([255, 0, 255, 0]).toString(),
+  'Encoded Array should be equal to [255, 0, 255, 0]'
+);
+
+const enumCoder = new EnumCoder('enum', { a: new NumberCoder('u32') });
+const encodedEnum = enumCoder.encode({ a: 255 });
+console.assert(
+  encodedEnum.toString() === new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255]).toString(),
+  'Encoded Enum should be equal to [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255]'
+);
+// #endregion working-with-bytes-5
+
+// #region working-with-bytes-6
+const vecCoder = new VecCoder(new NumberCoder('u8'));
+const encodedVec = vecCoder.encode([255, 0, 255]);
+console.assert(
+  encodedVec.toString() === new Uint8Array([0, 0, 0, 0, 0, 0, 0, 3, 255, 0, 255]).toString(),
+  'Encoded Vec should be equal to [0, 0, 0, 0, 0, 0, 0, 3, 255, 0, 255]'
+);
+
+const stdStringCoder = new StdStringCoder();
+const encodedStdString = stdStringCoder.encode('hello');
+console.assert(
+  encodedStdString.toString() ===
+    new Uint8Array([0, 0, 0, 0, 0, 0, 0, 5, 104, 101, 108, 108, 111]).toString(),
+  'Encoded StdString should be equal to [0, 0, 0, 0, 0, 0, 0, 5, 104, 101, 108, 108, 111]'
+);
+
+const rawSliceCoder = new RawSliceCoder();
+const encodedRawSlice = rawSliceCoder.encode([1, 2, 3, 4]);
+console.assert(
+  encodedRawSlice.toString() === new Uint8Array([0, 0, 0, 0, 0, 0, 0, 4, 1, 2, 3, 4]).toString(),
+  'Encoded RawSlice should be equal to [0, 0, 0, 0, 0, 0, 0, 4, 1, 2, 3, 4]'
+);
+// #endregion working-with-bytes-6
+// #endregion full