Add account management controller and accounts folder

src/abi/interaction.ts

@@ -1,4 +1,4 @@
-import { Account } from "../account";
+import { Account } from "../accounts";
 import { Address } from "../address";
 import { Compatibility } from "../compatibility";
 import { TRANSACTION_VERSION_DEFAULT } from "../constants";

src/accountManagement/accountController.ts

@@ -0,0 +1,62 @@
+import { IAccount } from "../accounts/interfaces";
+import { Transaction } from "../transaction";
+import { TransactionComputer } from "../transactionComputer";
+import { TransactionsFactoryConfig } from "../transactionsFactories";
+import { AccountTransactionsFactory } from "./accountTransactionsFactory";
+import { SaveKeyValueInput, SetGuardianInput } from "./resources";
+
+export class AccountController {
+    private factory: AccountTransactionsFactory;
+    private txComputer: TransactionComputer;
+
+    constructor(options: { chainID: string }) {
+        this.factory = new AccountTransactionsFactory({
+            config: new TransactionsFactoryConfig(options),
+        });
+        this.txComputer = new TransactionComputer();
+    }
+
+    async createTransactionForSavingKeyValue(
+        sender: IAccount,
+        nonce: bigint,
+        options: SaveKeyValueInput,
+    ): Promise<Transaction> {
+        const transaction = this.factory.createTransactionForSavingKeyValue(sender.address, options);
+
+        transaction.nonce = nonce;
+        transaction.signature = await sender.sign(this.txComputer.computeBytesForSigning(transaction));
+
+        return transaction;
+    }
+
+    async createTransactionForSettingGuardian(
+        sender: IAccount,
+        nonce: bigint,
+        options: SetGuardianInput,
+    ): Promise<Transaction> {
+        const transaction = this.factory.createTransactionForSettingGuardian(sender.address, options);
+
+        transaction.nonce = nonce;
+        transaction.signature = await sender.sign(this.txComputer.computeBytesForSigning(transaction));
+
+        return transaction;
+    }
+
+    async createTransactionForGuardingAccount(sender: IAccount, nonce: bigint): Promise<Transaction> {
+        const transaction = this.factory.createTransactionForGuardingAccount(sender.address);
+
+        transaction.nonce = nonce;
+        transaction.signature = await sender.sign(this.txComputer.computeBytesForSigning(transaction));
+
+        return transaction;
+    }
+
+    async createTransactionForUnguardingAccount(sender: IAccount, nonce: bigint): Promise<Transaction> {
+        const transaction = this.factory.createTransactionForUnguardingAccount(sender.address);
+
+        transaction.nonce = nonce;
+        transaction.signature = await sender.sign(this.txComputer.computeBytesForSigning(transaction));
+
+        return transaction;
+    }
+}

src/transactionsFactories/accountTransactionsFactory.spec.ts → src/accountManagement/accountTransactionsFactory.spec.ts

@@ -1,6 +1,6 @@
 import { assert } from "chai";
 import { Address } from "../address";
-import { TransactionsFactoryConfig } from "./transactionsFactoryConfig";
+import { TransactionsFactoryConfig } from "../transactionsFactories";
 import { AccountTransactionsFactory } from "./accountTransactionsFactory";
 
 describe("test account transactions factory", function () {
@@ -11,8 +11,7 @@ describe("test account transactions factory", function () {
         const sender = Address.fromBech32("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
         const keyValuePairs = new Map([[Buffer.from("key0"), Buffer.from("value0")]]);
 
-        const transaction = factory.createTransactionForSavingKeyValue({
-            sender: sender,
+        const transaction = factory.createTransactionForSavingKeyValue(sender, {
             keyValuePairs: keyValuePairs,
         });
 
@@ -29,8 +28,7 @@ describe("test account transactions factory", function () {
         const guardian = Address.fromBech32("erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx");
         const serviceID = "MultiversXTCSService";
 
-        const transaction = factory.createTransactionForSettingGuardian({
-            sender: sender,
+        const transaction = factory.createTransactionForSettingGuardian(sender, {
             guardianAddress: guardian,
             serviceID: serviceID,
         });
@@ -49,9 +47,7 @@ describe("test account transactions factory", function () {
     it("should create 'Transaction' for guarding account", async function () {
         const sender = Address.fromBech32("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
 
-        const transaction = factory.createTransactionForGuardingAccount({
-            sender: sender,
-        });
+        const transaction = factory.createTransactionForGuardingAccount(sender);
 
         assert.equal(transaction.sender, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
         assert.equal(transaction.receiver, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
@@ -64,9 +60,7 @@ describe("test account transactions factory", function () {
     it("should create 'Transaction' for unguarding account", async function () {
         const sender = Address.fromBech32("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
 
-        const transaction = factory.createTransactionForUnguardingAccount({
-            sender: sender,
-        });
+        const transaction = factory.createTransactionForUnguardingAccount(sender);
 
         assert.equal(transaction.sender, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
         assert.equal(transaction.receiver, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");

src/transactionsFactories/accountTransactionsFactory.ts → src/accountManagement/accountTransactionsFactory.ts

@@ -1,7 +1,8 @@
 import { Address } from "../address";
 import { IAddress } from "../interface";
 import { Transaction } from "../transaction";
-import { TransactionBuilder } from "./transactionBuilder";
+import { TransactionBuilder } from "../transactionsFactories/transactionBuilder";
+import { SaveKeyValueInput, SetGuardianInput } from "./resources";
 
 interface IConfig {
     chainID: string;
@@ -22,19 +23,16 @@ export class AccountTransactionsFactory {
         this.config = options.config;
     }
 
-    createTransactionForSavingKeyValue(options: {
-        sender: IAddress;
-        keyValuePairs: Map<Uint8Array, Uint8Array>;
-    }): Transaction {
+    createTransactionForSavingKeyValue(sender: IAddress, options: SaveKeyValueInput): Transaction {
         const functionName = "SaveKeyValue";
         const keyValueParts = this.computeDataPartsForSavingKeyValue(options.keyValuePairs);
         const dataParts = [functionName, ...keyValueParts];
         const extraGas = this.computeExtraGasForSavingKeyValue(options.keyValuePairs);
 
         return new TransactionBuilder({
             config: this.config,
-            sender: options.sender,
-            receiver: options.sender,
+            sender: sender,
+            receiver: sender,
             dataParts: dataParts,
             gasLimit: extraGas,
             addDataMovementGas: true,
@@ -63,11 +61,7 @@ export class AccountTransactionsFactory {
         return dataParts;
     }
 
-    createTransactionForSettingGuardian(options: {
-        sender: IAddress;
-        guardianAddress: IAddress;
-        serviceID: string;
-    }): Transaction {
+    createTransactionForSettingGuardian(sender: IAddress, options: SetGuardianInput): Transaction {
         const dataParts = [
             "SetGuardian",
             Address.fromBech32(options.guardianAddress.bech32()).toHex(),
@@ -76,34 +70,34 @@ export class AccountTransactionsFactory {
 
         return new TransactionBuilder({
             config: this.config,
-            sender: options.sender,
-            receiver: options.sender,
+            sender: sender,
+            receiver: sender,
             dataParts: dataParts,
             gasLimit: this.config.gasLimitSetGuardian,
             addDataMovementGas: true,
         }).build();
     }
 
-    createTransactionForGuardingAccount(options: { sender: IAddress }): Transaction {
+    createTransactionForGuardingAccount(sender: IAddress): Transaction {
         const dataParts = ["GuardAccount"];
 
         return new TransactionBuilder({
             config: this.config,
-            sender: options.sender,
-            receiver: options.sender,
+            sender: sender,
+            receiver: sender,
             dataParts: dataParts,
             gasLimit: this.config.gasLimitGuardAccount,
             addDataMovementGas: true,
         }).build();
     }
 
-    createTransactionForUnguardingAccount(options: { sender: IAddress }): Transaction {
+    createTransactionForUnguardingAccount(sender: IAddress): Transaction {
         const dataParts = ["UnGuardAccount"];
 
         return new TransactionBuilder({
             config: this.config,
-            sender: options.sender,
-            receiver: options.sender,
+            sender: sender,
+            receiver: sender,
             dataParts: dataParts,
             gasLimit: this.config.gasLimitUnguardAccount,
             addDataMovementGas: true,

src/accountManagement/index.ts

@@ -0,0 +1,2 @@
+export * from "./accountController";
+export * from "./accountTransactionsFactory";

src/accountManagement/resources.ts

@@ -0,0 +1,4 @@
+import { IAddress } from "../interface";
+
+export type SetGuardianInput = { guardianAddress: IAddress; serviceID: string };
+export type SaveKeyValueInput = { keyValuePairs: Map<Uint8Array, Uint8Array> };

src/accounts/account.ts

@@ -0,0 +1,113 @@
+import { Address } from "../address";
+import { LibraryConfig } from "../config";
+import { IAccountBalance, INonce } from "../interface";
+import { Mnemonic, UserSigner, UserWallet } from "../wallet";
+import { IAccount } from "./interfaces";
+
+/**
+ * An abstraction representing an account (user or Smart Contract) on the Network.
+ */
+export class Account implements IAccount {
+    /**
+     * The address of the account.
+     */
+    readonly address: Address = Address.empty();
+
+    /**
+     * The nonce of the account (the account sequence number).
+     */
+    nonce: INonce = 0;
+
+    /**
+     * @deprecated This will be remove with the next release as not needed anymore.
+     */
+    /**
+     * The balance of the account.
+     */
+    balance: IAccountBalance = "0";
+
+    /**
+     * The signer of the account.
+     */
+    private signer?: UserSigner;
+
+    /**
+     * Creates an account object from an address
+     */
+    constructor(address: Address, signer?: UserSigner) {
+        this.address = address;
+        this.signer = signer;
+    }
+
+    /**
+     * @deprecated This will be remove with the next release as not needed anymore.
+     */
+    /**
+     * Updates account properties (such as nonce, balance).
+     */
+    update(obj: { nonce: INonce; balance: IAccountBalance }) {
+        this.nonce = obj.nonce;
+        this.balance = obj.balance;
+    }
+
+    /**
+     * Increments (locally) the nonce (the account sequence number).
+     */
+    incrementNonce() {
+        this.nonce = this.nonce.valueOf() + 1;
+    }
+
+    /**
+     * Gets then increments (locally) the nonce (the account sequence number).
+     */
+    getNonceThenIncrement(): INonce {
+        let nonce = this.nonce;
+        this.nonce = this.nonce.valueOf() + 1;
+        return nonce;
+    }
+
+    /**
+     * Converts the account to a pretty, plain JavaScript object.
+     */
+    toJSON(): any {
+        return {
+            address: this.address.bech32(),
+            nonce: this.nonce.valueOf(),
+            balance: this.balance.toString(),
+        };
+    }
+
+    sign(data: Uint8Array): Promise<Uint8Array> {
+        if (!this.signer) {
+            throw new Error("Signer not initialiezed, please provide the signer when account is instantiated");
+        }
+        return this.signer.sign(data);
+    }
+
+    static newFromPem(path: string, index: number = 0, hrp: string = LibraryConfig.DefaultAddressHrp): Account {
+        const userSigner = UserSigner.fromPem(path, index);
+        return new Account(userSigner.getAddress(hrp), userSigner);
+    }
+
+    static newFromMnemonic(
+        mnemonic: string,
+        addressIndex: number = 0,
+        hrp: string = LibraryConfig.DefaultAddressHrp,
+    ): Account {
+        const mnemonicHandler = Mnemonic.fromString(mnemonic);
+        const secretKey = mnemonicHandler.deriveKey(addressIndex);
+        const userSigner = new UserSigner(secretKey);
+        return new Account(userSigner.getAddress(hrp), userSigner);
+    }
+
+    static newFromKeystore(
+        filePath: string,
+        password: string,
+        addressIndex?: number,
+        hrp: string = LibraryConfig.DefaultAddressHrp,
+    ): Account {
+        const secretKey = UserWallet.loadSecretKey(filePath, password, addressIndex);
+        const userSigner = new UserSigner(secretKey);
+        return new Account(userSigner.getAddress(hrp), userSigner);
+    }
+}

src/accounts/index.ts

@@ -0,0 +1,2 @@
+export * from "./account";
+export * from "./interfaces";