Add entrypoints

src/account.ts

@@ -1,10 +1,13 @@
 import { Address } from "./address";
+import { LibraryConfig } from "./config";
+import { IAccount } from "./controllers/interfaces";
 import { IAccountBalance, IAddress, INonce } from "./interface";
+import { UserSigner, UserWallet } from "./wallet";
 
 /**
  * An abstraction representing an account (user or Smart Contract) on the Network.
  */
-export class Account {
+export class Account implements IAccount {
     /**
      * The address of the account.
      */
@@ -15,18 +18,30 @@ export class Account {
      */
     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.
+     */
+    signer?: UserSigner;
+
     /**
      * Creates an account object from an address
      */
-    constructor(address: IAddress) {
+    constructor(address: IAddress, 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).
      */
@@ -61,4 +76,37 @@ export class Account {
             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 fromPem(path: string, hrp: string = LibraryConfig.DefaultAddressHrp): Account {
+        const userSigner = UserSigner.fromPem(path);
+        return new Account(userSigner.getAddress(hrp), userSigner);
+    }
+
+    static fromWallet(
+        keyFileObject: any,
+        password: string,
+        addressIndex?: number,
+        hrp: string = LibraryConfig.DefaultAddressHrp,
+    ): Account {
+        const userSigner = UserSigner.fromWallet(keyFileObject, password, addressIndex);
+        return new Account(userSigner.getAddress(hrp), userSigner);
+    }
+
+    static fromKeystore(
+        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/address.ts

@@ -3,8 +3,9 @@
 import { LibraryConfig } from "./config";
 import { CURRENT_NUMBER_OF_SHARDS_WITHOUT_META, METACHAIN_ID, WasmVirtualMachine } from "./constants";
 import * as errors from "./errors";
+import { IAddress } from "./interface";
 import { bigIntToBuffer } from "./tokenOperations/codec";
 const createKeccakHash = require("keccak");
 
 /**
  * The length (in bytes) of a public key (from which a bech32 address can be obtained).
@@ -13,15 +14,10 @@
 
 const SMART_CONTRACT_HEX_PUBKEY_PREFIX = "0".repeat(16);
 
-interface IAddress {
-    getPublicKey(): Buffer;
-    getHrp(): string;
-}
-
 /**
  * An Address, as an immutable object.
  */
-export class Address {
+export class Address implements IAddress {
     private readonly publicKey: Buffer;
     private readonly hrp: string;
 
@@ -298,7 +294,7 @@
 
     computeContractAddress(deployer: IAddress, deploymentNonce: bigint): Address {
         const initialPadding = Buffer.alloc(8, 0);
-        const ownerPubkey = deployer.getPublicKey();
+        const ownerPubkey = deployer.pubkey();
         const shardSelector = ownerPubkey.slice(30);
         const ownerNonceBytes = Buffer.alloc(8);
 
@@ -315,7 +311,7 @@
     }
 
     getShardOfAddress(address: IAddress): number {
-        return this.getShardOfPubkey(address.getPublicKey(), this.numberOfShardsWithoutMeta);
+        return this.getShardOfPubkey(address.pubkey(), this.numberOfShardsWithoutMeta);
     }
 
     private getShardOfPubkey(pubkey: Uint8Array, numberOfShards: number): number {

src/controllers/accountController.ts

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