(small breaking change) Merge v13's "TransactionNext" into the existing "Transaction" class

src/converters/index.ts

@@ -0,0 +1 @@
+export { TransactionsConverter } from "./transactionsConverter";

src/converters/transactionsConverter.ts

@@ -0,0 +1,64 @@
+import { IPlainTransactionObject, ITransaction } from "../interface";
+import { Transaction } from "../transaction";
+
+export class TransactionsConverter {
+    transactionToPlainObject(transaction: ITransaction): IPlainTransactionObject {
+        const plainObject = {
+            nonce: Number(transaction.nonce),
+            value: transaction.value.toString(),
+            receiver: transaction.receiver,
+            sender: transaction.sender,
+            senderUsername: this.toBase64OrUndefined(transaction.senderUsername),
+            receiverUsername: this.toBase64OrUndefined(transaction.receiverUsername),
+            gasPrice: Number(transaction.gasPrice),
+            gasLimit: Number(transaction.gasLimit),
+            data: this.toBase64OrUndefined(transaction.data),
+            chainID: transaction.chainID.valueOf(),
+            version: transaction.version,
+            options: transaction.options == 0 ? undefined : transaction.options,
+            guardian: transaction.guardian ? transaction.guardian : undefined,
+            signature: this.toHexOrUndefined(transaction.signature),
+            guardianSignature: this.toHexOrUndefined(transaction.guardianSignature),
+        };
+
+        return plainObject;
+    }
+
+    private toBase64OrUndefined(value?: string | Uint8Array) {
+        return value && value.length ? Buffer.from(value).toString("base64") : undefined;
+    }
+
+    private toHexOrUndefined(value?: Uint8Array) {
+        return value && value.length ? Buffer.from(value).toString("hex") : undefined;
+    }
+
+    public plainObjectToTransaction(object: IPlainTransactionObject): Transaction {
+        const transaction = new Transaction({
+            nonce: Number(object.nonce),
+            value: BigInt(object.value || ""),
+            receiver: object.receiver,
+            receiverUsername: this.bufferFromBase64(object.receiverUsername).toString(),
+            sender: object.sender,
+            senderUsername: this.bufferFromBase64(object.senderUsername).toString(),
+            guardian: object.guardian,
+            gasPrice: Number(object.gasPrice),
+            gasLimit: Number(object.gasLimit),
+            data: this.bufferFromBase64(object.data),
+            chainID: String(object.chainID),
+            version: object.version,
+            options: object.options,
+            signature: this.bufferFromHex(object.signature),
+            guardianSignature: this.bufferFromHex(object.guardianSignature),
+        });
+
+        return transaction;
+    }
+
+    private bufferFromBase64(value?: string) {
+        return Buffer.from(value || "", "base64");
+    }
+
+    private bufferFromHex(value?: string) {
+        return Buffer.from(value || "", "hex");
+    }
+}

src/converters/transactionsConverters.spec.ts

@@ -0,0 +1,23 @@
+import { assert } from "chai";
+import { Transaction } from "../transaction";
+
+describe("test transactions converter", async () => {
+    it("converts transaction to plain object and back", () => {
+        const transaction = new Transaction({
+            nonce: 90,
+            value: BigInt("123456789000000000000000000000"),
+            sender: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+            receiver: "erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx",
+            senderUsername: "alice",
+            receiverUsername: "bob",
+            gasPrice: 1000000000,
+            gasLimit: 80000,
+            data: Buffer.from("hello"),
+            chainID: "localnet",
+        });
+
+        const plainObject = transaction.toPlainObject();
+        const restoredTransaction = Transaction.fromPlainObject(plainObject);
+        assert.deepEqual(restoredTransaction, transaction);
+    });
+});

src/interface.ts

@@ -85,7 +85,7 @@ export interface ITokenTransfer {
  */
 export type ITokenPayment = ITokenTransfer;
 
-export interface ITransactionNext {
+export interface ITransaction {
     sender: string;
     receiver: string;
     gasLimit: bigint;

src/smartcontracts/smartContract.ts

@@ -118,7 +118,7 @@ export class SmartContract implements ISmartContract {
         Compatibility.guardAddressIsSetAndNonZero(deployer, "'deployer' of SmartContract.deploy()", "pass the actual address to deploy()");
 
         const config = new TransactionsFactoryConfig({ chainID: chainID.valueOf() });
-        const scNextTransactionFactory = new SmartContractTransactionsFactory({
+        const factory = new SmartContractTransactionsFactory({
             config: config,
             abi: this.abi,
             tokenComputer: new TokenComputer()
@@ -127,7 +127,7 @@ export class SmartContract implements ISmartContract {
         const bytecode = Buffer.from(code.toString(), 'hex');
         const metadataAsJson = this.getMetadataPropertiesAsObject(codeMetadata);
 
-        const nextTx = scNextTransactionFactory.createTransactionForDeploy({
+        const transaction = factory.createTransactionForDeploy({
             sender: deployer,
             bytecode: bytecode,
             gasLimit: BigInt(gasLimit.valueOf()),
@@ -138,7 +138,6 @@ export class SmartContract implements ISmartContract {
             isPayableBySmartContract: metadataAsJson.payableBySc
         });
 
-        const transaction = Transaction.fromTransactionNext(nextTx);
         transaction.setChainID(chainID);
         transaction.setValue(value ?? 0);
         transaction.setGasPrice(gasPrice ?? TRANSACTION_MIN_GAS_PRICE)
@@ -178,7 +177,7 @@ export class SmartContract implements ISmartContract {
         this.ensureHasAddress();
 
         const config = new TransactionsFactoryConfig({ chainID: chainID.valueOf() });
-        const scNextTransactionFactory = new SmartContractTransactionsFactory({
+        const factory = new SmartContractTransactionsFactory({
             config: config,
             abi: this.abi,
             tokenComputer: new TokenComputer()
@@ -187,7 +186,7 @@ export class SmartContract implements ISmartContract {
         const bytecode = Uint8Array.from(Buffer.from(code.toString(), 'hex'));
         const metadataAsJson = this.getMetadataPropertiesAsObject(codeMetadata);
 
-        const nextTx = scNextTransactionFactory.createTransactionForUpgrade({
+        const transaction = factory.createTransactionForUpgrade({
             sender: caller,
             contract: this.getAddress(),
             bytecode: bytecode,
@@ -199,7 +198,6 @@ export class SmartContract implements ISmartContract {
             isPayableBySmartContract: metadataAsJson.payableBySc
         })
 
-        const transaction = Transaction.fromTransactionNext(nextTx);
         transaction.setChainID(chainID);
         transaction.setValue(value ?? 0);
         transaction.setGasPrice(gasPrice ?? TRANSACTION_MIN_GAS_PRICE)
@@ -216,7 +214,7 @@ export class SmartContract implements ISmartContract {
         this.ensureHasAddress();
 
         const config = new TransactionsFactoryConfig({ chainID: chainID.valueOf() });
-        const scNextTransactionFactory = new SmartContractTransactionsFactory({
+        const factory = new SmartContractTransactionsFactory({
             config: config,
             abi: this.abi,
             tokenComputer: new TokenComputer()
@@ -225,15 +223,14 @@ export class SmartContract implements ISmartContract {
         args = args || [];
         value = value || 0;
 
-        const nextTx = scNextTransactionFactory.createTransactionForExecute({
+        const transaction = factory.createTransactionForExecute({
             sender: caller,
             contract: receiver ? receiver : this.getAddress(),
             functionName: func.toString(),
             gasLimit: BigInt(gasLimit.valueOf()),
             args: args
         })
 
-        const transaction = Transaction.fromTransactionNext(nextTx);
         transaction.setChainID(chainID);
         transaction.setValue(value);
         transaction.setGasPrice(gasPrice ?? TRANSACTION_MIN_GAS_PRICE)

src/testutils/networkProviders.ts

@@ -8,7 +8,7 @@ import {
     ITransactionStatus,
 } from "../interfaceOfNetwork";
 import { Query } from "../smartcontracts/query";
-import { Transaction, TransactionNext } from "../transaction";
+import { Transaction } from "../transaction";
 
 export function createLocalnetProvider(): INetworkProvider {
     return new ProxyNetworkProvider("http://localhost:7950", { timeout: 5000 });
@@ -23,7 +23,7 @@ export interface INetworkProvider {
     getAccount(address: IAddress): Promise<IAccountOnNetwork>;
     getTransaction(txHash: string, withProcessStatus?: boolean): Promise<ITransactionOnNetwork>;
     getTransactionStatus(txHash: string): Promise<ITransactionStatus>;
-    sendTransaction(tx: Transaction | TransactionNext): Promise<string>;
+    sendTransaction(tx: Transaction): Promise<string>;
     simulateTransaction(tx: Transaction): Promise<any>;
     queryContract(query: Query): Promise<IContractQueryResponse>;
 }