Transfer transactions factory

src/transactionsFactories/smartContractTransactionsFactory.spec.ts

@@ -209,12 +209,14 @@ describe("test smart contract transactions factory", function () {
 
  assert.equal(executeDraft.sender, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
  assert.equal(executeDraft.receiver, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
+
  assert.deepEqual(
  executeDraft.data,
  Buffer.from(
  "MultiESDTNFTTransfer@00000000000000000500ed8e25a94efa837aae0e593112cfbb01b448755069e1@02@464f4f2d366365313762@00@0a@4241522d356263303866@00@0c44@616464@07"
  )
  );
+
  assert.equal(executeDraft.gasLimit.valueOf(), gasLimit);
  assert.equal(executeDraft.value.valueOf(), "0");
 
@@ -250,12 +252,15 @@ describe("test smart contract transactions factory", function () {
 
  assert.equal(executeDraft.sender, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
  assert.equal(executeDraft.receiver, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
+
+ assert.isDefined(executeDraft.data);
  assert.deepEqual(
  executeDraft.data,
  Buffer.from(
  "ESDTNFTTransfer@4e46542d313233343536@01@01@00000000000000000500b9353fe8407f87310c87e12fa1ac807f0485da39d152@616464@07"
  )
  );
+
  assert.equal(executeDraft.gasLimit.valueOf(), gasLimit);
  assert.equal(executeDraft.value.valueOf(), "0");
 
@@ -293,12 +298,15 @@ describe("test smart contract transactions factory", function () {
 
  assert.equal(executeDraft.sender, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
  assert.equal(executeDraft.receiver, "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
+
+ assert.isDefined(executeDraft.data);
  assert.deepEqual(
  executeDraft.data,
  Buffer.from(
  "MultiESDTNFTTransfer@00000000000000000500b9353fe8407f87310c87e12fa1ac807f0485da39d152@02@4e46542d313233343536@01@01@4e46542d313233343536@2a@01@616464@07"
  )
  );
+
  assert.equal(executeDraft.gasLimit.valueOf(), gasLimit);
  assert.equal(executeDraft.value.valueOf(), "0");
 

src/transactionsFactories/transactionsFactoryConfig.ts

@@ -27,6 +27,9 @@ export class TransactionsFactoryConfig {
  gasLimitDelegationOperations: BigNumber.Value;
  additionalGasLimitPerValidatorNode: BigNumber.Value;
  additionalGasLimitForDelegationOperations: BigNumber.Value;
+ gasLimitESDTTransfer: BigNumber.Value;
+ gasLimitESDTNFTTransfer: BigNumber.Value;
+ gasLimitMultiESDTNFTTransfer: BigNumber.Value;
 
  constructor(chainId: string) {
  // General-purpose configuration
@@ -59,5 +62,10 @@ export class TransactionsFactoryConfig {
  this.gasLimitDelegationOperations = new BigNumber(1000000);
  this.additionalGasLimitPerValidatorNode = new BigNumber(6000000);
  this.additionalGasLimitForDelegationOperations = new BigNumber(10000000);
+
+ // Configuration for token transfers
+ this.gasLimitESDTTransfer = new BigNumber(200000);
+ this.gasLimitESDTNFTTransfer = new BigNumber(200000);
+ this.gasLimitMultiESDTNFTTransfer = new BigNumber(200000);
  }
 }

src/transactionsFactories/transferTransactionsFactory.spec.ts

@@ -0,0 +1,119 @@
+import { assert } from "chai";
+import { Address } from "../address";
+import { Token, NextTokenTransfer, TokenComputer } from "../tokens";
+import { TransactionsFactoryConfig } from "./transactionsFactoryConfig";
+import { TransferTransactionsFactory } from "./transferTransactionsFactory";
+import { ErrBadUsage } from "../errors";
+
+describe("test transfer transcations factory", function () {
+ const config = new TransactionsFactoryConfig("D");
+ const factory = new TransferTransactionsFactory(config, new TokenComputer());
+
+ const alice = Address.fromBech32("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th");
+ const bob = Address.fromBech32("erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx");
+
+ it("should throw error, no token transfer provided", async () => {
+ let transfers: any = [];
+
+ assert.throw(
+ () => {
+ factory.createTransactionForESDTTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ tokenTransfers: transfers,
+ });
+ },
+ ErrBadUsage,
+ "No token transfer has been provided"
+ );
+ });
+
+ it("should create draft transaction for native token transfer without data", async () => {
+ const transaction = factory.createTransactionForNativeTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ nativeAmount: "1000000000000000000",
+ });
+
+ assert.equal(transaction.sender, alice.bech32());
+ assert.equal(transaction.receiver, bob.bech32());
+ assert.equal(transaction.value.valueOf(), "1000000000000000000");
+ assert.equal(transaction.gasLimit.valueOf(), "50000");
+ assert.deepEqual(transaction.data, new Uint8Array());
+ });
+
+ it("should create draft transaction for native token transfer with data", async () => {
+ const transaction = factory.createTransactionForNativeTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ nativeAmount: "1000000000000000000",
+ data: "test data",
+ });
+
+ assert.equal(transaction.sender, alice.bech32());
+ assert.equal(transaction.receiver, bob.bech32());
+ assert.equal(transaction.value.valueOf(), "1000000000000000000");
+ assert.equal(transaction.gasLimit.valueOf(), "63500");
+ assert.deepEqual(transaction.data, Buffer.from("test data"));
+ });
+
+ it("should create draft transaction for esdt transfer", async () => {
+ const fooToken = new Token("FOO-123456", 0);
+ const transfer = new NextTokenTransfer(fooToken, 1000000);
+
+ const transaction = factory.createTransactionForESDTTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ tokenTransfers: [transfer],
+ });
+
+ assert.equal(transaction.sender, alice.bech32());
+ assert.equal(transaction.receiver, bob.bech32());
+ assert.equal(transaction.value.valueOf(), "0");
+ assert.equal(transaction.gasLimit.valueOf(), "410000");
+ assert.deepEqual(transaction.data.toString(), "ESDTTransfer@464f4f2d313233343536@0f4240");
+ });
+
+ it("should create draft transaction for nft transfer", async () => {
+ const nft = new Token("NFT-123456", 10);
+ const transfer = new NextTokenTransfer(nft, 1);
+
+ const transaction = factory.createTransactionForESDTTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ tokenTransfers: [transfer],
+ });
+
+ assert.equal(transaction.sender, alice.bech32());
+ assert.equal(transaction.receiver, alice.bech32());
+ assert.equal(transaction.value.valueOf(), "0");
+ assert.equal(transaction.gasLimit.valueOf(), "1210500");
+ assert.deepEqual(
+ transaction.data.toString(),
+ "ESDTNFTTransfer@4e46542d313233343536@0a@01@8049d639e5a6980d1cd2392abcce41029cda74a1563523a202f09641cc2618f8"
+ );
+ });
+
+ it("should create draft transaction for multiple nft transfers", async () => {
+ const firstNft = new Token("NFT-123456", 10);
+ const firstTransfer = new NextTokenTransfer(firstNft, 1);
+
+ const secondNft = new Token("TEST-987654", 1);
+ const secondTransfer = new NextTokenTransfer(secondNft, 1);
+
+ const transaction = factory.createTransactionForESDTTokenTransfer({
+ sender: alice,
+ receiver: bob,
+ tokenTransfers: [firstTransfer, secondTransfer],
+ });
+
+ assert.equal(transaction.sender, alice.bech32());
+ assert.equal(transaction.receiver, alice.bech32());
+ assert.equal(transaction.value.valueOf(), "0");
+ assert.equal(transaction.gasLimit.valueOf(), "1466000");
+ assert.deepEqual(
+ transaction.data.toString(),
+ "MultiESDTNFTTransfer@8049d639e5a6980d1cd2392abcce41029cda74a1563523a202f09641cc2618f8@02@4e46542d313233343536@0a@01@544553542d393837363534@01@01"
+ );
+ });
+});

src/transactionsFactories/transferTransactionsFactory.ts

@@ -0,0 +1,120 @@
+import BigNumber from "bignumber.js";
+import { TokenTransfersDataBuilder } from "./tokenTransfersDataBuilder";
+import { IAddress } from "../interface";
+import { DraftTransaction } from "../draftTransaction";
+import { DraftTransactionBuilder } from "./draftTransactionBuilder";
+import { NextTokenTransfer, Token } from "../tokens";
+import { ErrBadUsage } from "../errors";
+
+const ADDITIONAL_GAS_FOR_ESDT_TRANSFER = 100000;
+const ADDITIONAL_GAS_FOR_ESDT_NFT_TRANSFER = 800000;
+
+interface IConfig {
+ chainID: string;
+ minGasLimit: BigNumber.Value;
+ gasLimitPerByte: BigNumber.Value;
+ gasLimitESDTTransfer: BigNumber.Value;
+ gasLimitESDTNFTTransfer: BigNumber.Value;
+ gasLimitMultiESDTNFTTransfer: BigNumber.Value;
+}
+
+interface TokenComputer {
+ isFungible(token: Token): boolean;
+}
+
+export class TransferTransactionsFactory {
+ private readonly config: IConfig;
+ private readonly dataArgsBuilder: TokenTransfersDataBuilder;
+ private readonly tokenComputer: TokenComputer;
+
+ constructor(config: IConfig, tokenComputer: TokenComputer) {
+ this.config = config;
+ this.tokenComputer = tokenComputer;
+ this.dataArgsBuilder = new TokenTransfersDataBuilder();
+ }
+
+ createTransactionForNativeTokenTransfer(options: {
+ sender: IAddress;
+ receiver: IAddress;
+ nativeAmount: BigNumber.Value;
+ data?: string;
+ }): DraftTransaction {
+ const data = options.data || "";
+ return new DraftTransactionBuilder({
+ config: this.config,
+ sender: options.sender,
+ receiver: options.receiver,
+ dataParts: [data],
+ gasLimit: 0,
+ addDataMovementGas: true,
+ amount: options.nativeAmount,
+ }).build();
+ }
+
+ createTransactionForESDTTokenTransfer(options: {
+ sender: IAddress;
+ receiver: IAddress;
+ tokenTransfers: NextTokenTransfer[];
+ }): DraftTransaction {
+ const numberOfTransfers = options.tokenTransfers.length;
+
+ if (numberOfTransfers === 0) {
+ throw new ErrBadUsage("No token transfer has been provided");
+ }
+
+ if (numberOfTransfers === 1) {
+ return this.createSingleESDTTransferDraft(options);
+ }
+
+ const transferArgs = this.dataArgsBuilder.buildArgsForMultiESDTNFTTransfer(
+ options.receiver,
+ options.tokenTransfers
+ );
+
+ const extraGasForTransfer = new BigNumber(this.config.gasLimitMultiESDTNFTTransfer)
+ .multipliedBy(new BigNumber(numberOfTransfers))
+ .plus(new BigNumber(ADDITIONAL_GAS_FOR_ESDT_NFT_TRANSFER));
+
+ return new DraftTransactionBuilder({
+ config: this.config,
+ sender: options.sender,
+ receiver: options.sender,
+ dataParts: transferArgs,
+ gasLimit: extraGasForTransfer,
+ addDataMovementGas: true,
+ }).build();
+ }
+
+ private createSingleESDTTransferDraft(options: {
+ sender: IAddress;
+ receiver: IAddress;
+ tokenTransfers: NextTokenTransfer[];
+ }): DraftTransaction {
+ let transferArgs: string[] = [];
+ const transfer = options.tokenTransfers[0];
+ let extraGasForTransfer = new BigNumber(0);
+ let receiver = options.receiver;
+
+ if (this.tokenComputer.isFungible(transfer.token)) {
+ transferArgs = this.dataArgsBuilder.buildArgsForESDTTransfer(transfer);
+ extraGasForTransfer = new BigNumber(this.config.gasLimitESDTTransfer).plus(
+ new BigNumber(ADDITIONAL_GAS_FOR_ESDT_TRANSFER)
+ );
+ } else {
+ transferArgs = this.dataArgsBuilder.buildArgsForSingleESDTNFTTransfer(transfer, receiver);
+ extraGasForTransfer = new BigNumber(this.config.gasLimitESDTNFTTransfer).plus(
+ new BigNumber(ADDITIONAL_GAS_FOR_ESDT_NFT_TRANSFER)
+ );
+ receiver = options.sender;
+ }
+
+ return new DraftTransactionBuilder({
+ config: this.config,
+ sender: options.sender,
+ receiver: receiver,
+ dataParts: transferArgs,
+ gasLimit: extraGasForTransfer,
+ addDataMovementGas: true,
+ }).build();
+ }
+}