chore: src-01 and sro-01

packages/core/src/transaction/Clause.ts

@@ -8,13 +8,14 @@
     type ABIFunction,
     type Address,
     type HexUInt,
     type VTHO
 } from '../vcdm';
 import { Hex } from '../vcdm/Hex';
 import { HexInt } from '../vcdm/HexInt';
 import type { ClauseOptions } from './ClauseOptions';
 import type { DeployParams } from './DeployParams';
 import type { TransactionClause } from './TransactionClause';
+import { type FungibleToken } from '../vcdm/currency/FungibleToken';
 
 /**
  * This class represent a transaction clause.
@@ -221,7 +222,7 @@
      *
      * @param {Address} tokenAddress - The address of the VIP180 token.
      * @param {Address} recipientAddress - The address of the recipient.
-     * @param {VTHO} amount - The amount of token to be transferred.
+     * @param {FungibleToken} amount - The amount of token to be transferred.
      * @param {ClauseOptions} [clauseOptions] - Optional clause settings.
      * @return {Clause} The clause to transfer VIP180 tokens as part of a transaction.
      * @throws {InvalidDataType} Throws an error if the amount is not a positive integer.
@@ -231,7 +232,7 @@
     public static transferToken(
         tokenAddress: Address,
         recipientAddress: Address,
-        amount: VTHO,
+        amount: FungibleToken,
         clauseOptions?: ClauseOptions
     ): Clause {
         if (amount.value.isFinite() && amount.value.isPositive()) {

packages/core/src/vcdm/currency/FungibleToken.ts

@@ -0,0 +1,39 @@
+import { type FixedPointNumber } from '../FixedPointNumber';
+import { type Txt } from '../Txt';
+import { Coin } from './Coin';
+
+/**
+ * Represents a fungible token monetary amount.
+ *
+ * @extends Coin
+ */
+class FungibleToken extends Coin {
+    /**
+     * Wei default decimals.
+     */
+    private static readonly WEI_DEFAULT = 18n;
+
+    /**
+     * Wei number of fractional digits to express the token with.
+     */
+    private readonly _decimals: bigint;
+
+    /**
+     * Represents this monetary amount in terms of {@link Units.wei}.
+     *
+     * @type {bigint}
+     */
+    public readonly wei: bigint;
+
+    protected constructor(
+        symbol: Txt,
+        value: FixedPointNumber,
+        decimals: bigint = FungibleToken.WEI_DEFAULT
+    ) {
+        super(symbol, value);
+        this._decimals = decimals;
+        this.wei = value.dp(this._decimals).scaledValue;
+    }
+}
+
+export { FungibleToken };

packages/core/src/vcdm/currency/VTHO.ts

@@ -1,16 +1,16 @@
-import { Coin } from './Coin';
 import { FixedPointNumber } from '../FixedPointNumber';
 import { Txt } from '../Txt';
 import { Units } from './Units';
+import { FungibleToken } from './FungibleToken';
 
 /**
  * Represents a
  * [VeChain VeThor](https://docs.vechain.org/introduction-to-vechain/dual-token-economic-model/vethor-vtho)
  * monetary amount.
  *
- * @extends Coin
+ * @extends FungibleToken
  */
-class VTHO extends Coin {
+class VTHO extends FungibleToken {
     /**
      * The code for VET is the sequence of Unicode
      * - U+1D64D - mathematical double strike capital letter 'V',
@@ -23,22 +23,15 @@ class VTHO extends Coin {
     /**
      * Wei fractional digits to express this value.
      */
-    private static readonly WEI_FD = 18n;
-
-    /**
-     * Represents this monetary amount in terms of {@link Units.wei}.
-     *
-     * @type {bigint}
-     */
-    public readonly wei: bigint = this.value.dp(VTHO.WEI_FD).scaledValue;
+    private static readonly VTHO_DECIMALS = 18n;
 
     /**
      * Create a new instance with the given `value`.
      *
      * @param {FixedPointNumber} value The value to be used for initializing the instance.
      */
     protected constructor(value: FixedPointNumber) {
-        super(VTHO.CODE, value);
+        super(VTHO.CODE, value, VTHO.VTHO_DECIMALS);
     }
 
     /**
@@ -60,7 +53,9 @@ class VTHO extends Coin {
                 ? value
                 : FixedPointNumber.of(value);
         return new VTHO(
-            fpn.div(FixedPointNumber.of(10n ** (VTHO.WEI_FD - BigInt(unit))))
+            fpn.div(
+                FixedPointNumber.of(10n ** (VTHO.VTHO_DECIMALS - BigInt(unit)))
+            )
         );
     }
 }

packages/core/tests/vcdm/currency/FungibleToken.unit.test.ts

@@ -0,0 +1,47 @@
+import { expect } from '@jest/globals';
+import { FixedPointNumber, Txt } from '../../../src';
+import { FungibleToken } from '../../../src/vcdm/currency/FungibleToken';
+
+/**
+ * Test FungibleToken class.
+ * @group unit/vcdm
+ */
+
+const tokenValue = '123456789.012345678';
+const tokenDecimals = 20n; // 18 decimals is tested via VTHO
+
+class TestToken extends FungibleToken {
+    constructor(value: FixedPointNumber) {
+        super(Txt.of('TEST'), value, tokenDecimals);
+    }
+}
+
+class DefaultDecimalsToken extends FungibleToken {
+    constructor(value: FixedPointNumber) {
+        super(Txt.of('DEFAULT'), value);
+    }
+}
+
+describe('FungibleToken tests', () => {
+    test('toString method', () => {
+        const token = new TestToken(FixedPointNumber.of(tokenValue));
+        const expected = `${Txt.of(tokenValue)} ${token.code}`;
+        const actual = token.toString();
+        expect(actual).toEqual(expected);
+    });
+
+    test('Wei value', () => {
+        const expectedWei =
+            FixedPointNumber.of(tokenValue).dp(tokenDecimals).scaledValue;
+        const token = new TestToken(FixedPointNumber.of(tokenValue));
+        const actualWei = token.wei;
+        expect(actualWei).toEqual(expectedWei);
+    });
+
+    test('Default decimals', () => {
+        const expectedWei = FixedPointNumber.of(tokenValue).dp(18n).scaledValue;
+        const token = new DefaultDecimalsToken(FixedPointNumber.of(tokenValue));
+        const actualWei = token.wei;
+        expect(actualWei).toEqual(expectedWei);
+    });
+});

packages/core/tests/vcdm/currency/VTHO.unit.test.ts

@@ -24,4 +24,12 @@ describe('VTHO class tests', () => {
         ).toString();
         expect(actual).toEqual(expected);
     });
+
+    test('Wei value', () => {
+        const expected = FixedPointNumber.of(VTHOFixture.value).dp(
+            18n
+        ).scaledValue;
+        const actual = VTHO.of(FixedPointNumber.of(VTHOFixture.value)).wei;
+        expect(actual).toEqual(expected);
+    });
 });

packages/network/src/provider/providers/hardhat-provider/hardhat-provider.ts

@@ -77,7 +77,7 @@ class HardhatVeChainProvider extends VeChainProvider {
     }
 
     /**
-     * Overload off the send method
+     * Overload of the send method
      *
      * @param method - The method to call.
      * @param params - The parameters to pass to the method.

packages/network/src/signer/signers/vechain-abstract-signer/vechain-abstract-signer.ts

@@ -195,9 +195,9 @@ abstract class VeChainAbstractSigner implements VeChainSigner {
 
     /**
      * Estimates the required gas required to execute //tx// on the Blockchain. This
-     * will be the expected amount a transaction will require
+     * will be the expected amount a transaction will need
      * to successfully run all the necessary computations and store the needed state
-     * that the transaction intends.
+     * for the transaction.
      *
      * @param transactionToEstimate - The transaction to estimate gas for
      * @returns the total estimated gas required