Merge pull request #414 from multiversx/drop-next-prefix

"LegacyTokenTransfer" vs. "NextTokenTransfer"

src/index.ts

@@ -14,10 +14,9 @@ export * from "./relayedTransactionV2Builder";
 export * from "./signableMessage";
 export * from "./smartcontracts";
 export * from "./tokenOperations";
-export * from "./tokenTransfer";
 export * from "./tokens";
 export * from "./transaction";
+export * from "./transactionComputer";
 export * from "./transactionPayload";
 export * from "./transactionWatcher";
 export * from "./utils";
-export * from "./transactionComputer";

src/proto/serializer.spec.ts

@@ -3,7 +3,7 @@ import { Address } from "../address";
 import { TransactionVersion } from "../networkParams";
 import { Signature } from "../signature";
 import { loadTestWallets, TestWallet } from "../testutils";
-import { TokenTransfer } from "../tokenTransfer";
+import { TokenTransfer } from "../tokens";
 import { Transaction } from "../transaction";
 import { TransactionPayload } from "../transactionPayload";
 import { ProtoSerializer } from "./serializer";

src/relayedTransactionV1Builder.spec.ts

@@ -4,7 +4,7 @@ import * as errors from "./errors";
 import { TransactionOptions, TransactionVersion } from "./networkParams";
 import { RelayedTransactionV1Builder } from "./relayedTransactionV1Builder";
 import { TestWallet, loadTestWallets } from "./testutils";
-import { TokenTransfer } from "./tokenTransfer";
+import { TokenTransfer } from "./tokens";
 import { Transaction } from "./transaction";
 import { TransactionPayload } from "./transactionPayload";
 

src/smartcontracts/interaction.spec.ts

@@ -10,7 +10,7 @@ import {
     TestWallet
 } from "../testutils";
 import { ContractController } from "../testutils/contractController";
-import { TokenTransfer } from "../tokenTransfer";
+import { TokenTransfer } from "../tokens";
 import { ContractFunction } from "./function";
 import { Interaction } from "./interaction";
 import { ReturnCode } from "./returnCode";

src/smartcontracts/interactionChecker.spec.ts

@@ -2,7 +2,7 @@ import { assert } from "chai";
 import { Address } from "../address";
 import * as errors from "../errors";
 import { loadAbiRegistry } from "../testutils";
-import { TokenTransfer } from "../tokenTransfer";
+import { TokenTransfer } from "../tokens";
 import { Interaction } from "./interaction";
 import { InteractionChecker } from "./interactionChecker";
 import { SmartContract } from "./smartContract";

src/tokenTransferBuilders.spec.ts

@@ -1,6 +1,6 @@
 import { assert } from "chai";
 import { Address } from "./address";
-import { TokenTransfer } from "./tokenTransfer";
+import { TokenTransfer } from "./tokens";
 import {
     ESDTNFTTransferPayloadBuilder,
     ESDTTransferPayloadBuilder,

src/tokenTransferBuilders.ts

@@ -2,7 +2,7 @@ import { Address } from "./address";
 import { IAddress, ITokenTransfer } from "./interface";
 import { ArgSerializer } from "./smartcontracts/argSerializer";
 import { AddressValue, BigUIntValue, BytesValue, TypedValue, U16Value, U64Value } from "./smartcontracts/typesystem";
-import { TokenTransfer } from "./tokenTransfer";
+import { TokenTransfer } from "./tokens";
 import { TransactionPayload } from "./transactionPayload";
 
 /**

src/tokens.spec.ts

@@ -1,12 +1,12 @@
 import { assert } from "chai";
-import { Token, TokenComputer } from "./tokens";
+import { Token, TokenComputer, TokenTransfer } from "./tokens";
 
-describe("test token computer", async () => {
+describe("test tokens and token computer", async () => {
     const tokenComputer = new TokenComputer();
 
     it("should test if token is fungible", async () => {
-        const fungibleToken = new Token("TEST-123456", 0n);
-        const nonFungibleToken = new Token("NFT-987654", 7n);
+        const fungibleToken = new Token({ identifier: "TEST-123456", nonce: 0n });
+        const nonFungibleToken = new Token({ identifier: "NFT-987654", nonce: 7n });
 
         assert.equal(tokenComputer.isFungible(fungibleToken), true);
         assert.equal(tokenComputer.isFungible(nonFungibleToken), false);
@@ -32,3 +32,67 @@ describe("test token computer", async () => {
         assert.equal(identifier, "FNG-123456");
     });
 });
+
+describe("test token transfer (legacy)", () => {
+    it("should work with EGLD", () => {
+        assert.equal(TokenTransfer.egldFromAmount("1").toString(), "1000000000000000000");
+        assert.equal(TokenTransfer.egldFromAmount("10").toString(), "10000000000000000000");
+        assert.equal(TokenTransfer.egldFromAmount("100").toString(), "100000000000000000000");
+        assert.equal(TokenTransfer.egldFromAmount("1000").toString(), "1000000000000000000000");
+        assert.equal(TokenTransfer.egldFromAmount("0.1").toString(), "100000000000000000");
+        assert.equal(TokenTransfer.egldFromAmount("0.123456789").toString(), "123456789000000000");
+        assert.equal(TokenTransfer.egldFromAmount("0.123456789123456789").toString(), "123456789123456789");
+        assert.equal(TokenTransfer.egldFromAmount("0.123456789123456789777").toString(), "123456789123456789");
+        assert.equal(TokenTransfer.egldFromAmount("0.123456789123456789777777888888").toString(), "123456789123456789");
+
+        assert.equal(TokenTransfer.egldFromAmount(0.1).toPrettyString(), "0.100000000000000000 EGLD");
+        assert.equal(TokenTransfer.egldFromAmount(1).toPrettyString(), "1.000000000000000000 EGLD");
+        assert.equal(TokenTransfer.egldFromAmount(10).toPrettyString(), "10.000000000000000000 EGLD");
+        assert.equal(TokenTransfer.egldFromAmount(100).toPrettyString(), "100.000000000000000000 EGLD");
+        assert.equal(TokenTransfer.egldFromAmount(1000).toPrettyString(), "1000.000000000000000000 EGLD");
+        assert.equal(TokenTransfer.egldFromAmount("0.123456789").toPrettyString(), "0.123456789000000000 EGLD");
+        assert.equal(
+            TokenTransfer.egldFromAmount("0.123456789123456789777777888888").toPrettyString(),
+            "0.123456789123456789 EGLD",
+        );
+
+        assert.equal(TokenTransfer.egldFromBigInteger("1").toString(), "1");
+        assert.equal(TokenTransfer.egldFromBigInteger("1").toPrettyString(), "0.000000000000000001 EGLD");
+        assert.isTrue(TokenTransfer.egldFromAmount("1").isEgld());
+    });
+
+    it("should work with USDC (legacy)", () => {
+        const identifier = "USDC-c76f1f";
+        const numDecimals = 6;
+
+        assert.equal(TokenTransfer.fungibleFromAmount(identifier, "1", numDecimals).toString(), "1000000");
+        assert.equal(TokenTransfer.fungibleFromAmount(identifier, "0.1", numDecimals).toString(), "100000");
+        assert.equal(TokenTransfer.fungibleFromAmount(identifier, "0.123456789", numDecimals).toString(), "123456");
+        assert.equal(TokenTransfer.fungibleFromBigInteger(identifier, "1000000", numDecimals).toString(), "1000000");
+        assert.equal(
+            TokenTransfer.fungibleFromBigInteger(identifier, "1000000", numDecimals).toPrettyString(),
+            "1.000000 USDC-c76f1f",
+        );
+    });
+
+    it("should work with MetaESDT (legacy)", () => {
+        const identifier = "MEXFARML-28d646";
+        const numDecimals = 18;
+        const nonce = 12345678;
+        const transfer = TokenTransfer.metaEsdtFromAmount(identifier, nonce, "0.1", numDecimals);
+
+        assert.equal(transfer.tokenIdentifier, identifier);
+        assert.equal(transfer.nonce, nonce);
+        assert.equal(transfer.toString(), "100000000000000000");
+    });
+
+    it("should work with NFTs (legacy)", () => {
+        const identifier = "TEST-38f249";
+        const nonce = 1;
+        const transfer = TokenTransfer.nonFungible(identifier, nonce);
+
+        assert.equal(transfer.tokenIdentifier, identifier);
+        assert.equal(transfer.nonce, nonce);
+        assert.equal(transfer.toPrettyString(), "1 TEST-38f249");
+    });
+});