Elrond ESDT tokens & EGLD staking integration

src/families/elrond/api/apiCalls.ts

@@ -2,8 +2,16 @@ import network from "../../../network";
 import {
   HASH_TRANSACTION,
   METACHAIN_SHARD,
-  TRANSACTIONS_SIZE,
+  MAX_PAGINATION_SIZE,
+  ESDT_TRANSFER_GAS,
 } from "../constants";
+import {
+  ElrondProtocolTransaction,
+  ElrondTransferOptions,
+  ESDTToken,
+  NetworkInfo,
+  Transaction,
+} from "../types";
 export default class ElrondApi {
   private API_URL: string;
 
@@ -18,6 +26,7 @@ export default class ElrondApi {
       method: "GET",
       url: `${this.API_URL}/accounts/${addr}`,
     });
+
     return {
       balance,
       nonce,
@@ -42,7 +51,7 @@ export default class ElrondApi {
     return data;
   }
 
-  async getNetworkConfig() {
+  async getNetworkConfig(): Promise<NetworkInfo> {
     const {
       data: {
         data: {
@@ -52,77 +61,156 @@ export default class ElrondApi {
             erd_min_gas_limit: gasLimit,
             erd_min_gas_price: gasPrice,
             erd_gas_per_data_byte: gasPerByte,
+            erd_gas_price_modifier: gasPriceModifier,
           },
         },
       },
     } = await network({
       method: "GET",
       url: `${this.API_URL}/network/config`,
     });
+
     return {
-      chainId,
+      chainID: chainId,
       denomination,
       gasLimit,
       gasPrice,
       gasPerByte,
+      gasPriceModifier,
     };
   }
 
   async submit({ operation, signature }) {
-    const { chainId, gasLimit, gasPrice } = await this.getNetworkConfig();
+    const networkConfig: NetworkInfo = await this.getNetworkConfig();
+    const { chainID, gasPrice } = networkConfig;
+    let gasLimit = networkConfig.gasLimit;
+
     const {
       senders: [sender],
       recipients: [receiver],
       value,
       transactionSequenceNumber: nonce,
+      extra: { data },
     } = operation;
+
+    if (data) {
+      // gasLimit for an ESDT transfer
+      gasLimit = ESDT_TRANSFER_GAS;
+    }
+
+    const transaction: ElrondProtocolTransaction = {
+      nonce,
+      value,
+      receiver,
+      sender,
+      gasPrice,
+      gasLimit,
+      chainID,
+      signature,
+      data,
+      ...HASH_TRANSACTION,
+    };
+
     const {
       data: {
         data: { txHash: hash },
       },
     } = await network({
       method: "POST",
       url: `${this.API_URL}/transaction/send`,
-      data: {
-        nonce,
-        value,
-        receiver,
-        sender,
-        gasPrice,
-        gasLimit,
-        chainID: chainId,
-        signature,
-        ...HASH_TRANSACTION,
-      },
+      data: transaction,
     });
-    return {
-      hash,
-    };
+
+    return hash;
   }
 
-  async getHistory(addr: string, startAt: number) {
+  async getHistory(addr: string, startAt: number): Promise<Transaction[]> {
     const { data: transactionsCount } = await network({
       method: "GET",
-      url: `${this.API_URL}/transactions/count?condition=should&sender=${addr}&receiver=${addr}&after=${startAt}`,
+      url: `${this.API_URL}/accounts/${addr}/transactions/count?after=${startAt}`,
     });
 
-    let allTransactions: any[] = [];
+    let allTransactions: Transaction[] = [];
     let from = 0;
     while (from <= transactionsCount) {
-      const { data: transactions } = await network({
+      let { data: transactions } = await network({
         method: "GET",
-        url: `${this.API_URL}/transactions?condition=should&sender=${addr}&receiver=${addr}&after=${startAt}&from=${from}&size=${TRANSACTIONS_SIZE}`,
+        url: `${this.API_URL}/accounts/${addr}/transactions?after=${startAt}&from=${from}&size=${MAX_PAGINATION_SIZE}`,
       });
 
+      transactions = transactions.filter(
+        (transaction) => !transaction.tokenIdentifier
+      );
+
       allTransactions = [...allTransactions, ...transactions];
 
-      from = from + TRANSACTIONS_SIZE;
+      from = from + MAX_PAGINATION_SIZE;
     }
 
     return allTransactions;
   }
 
-  async getBlockchainBlockHeight() {
+  async getESDTTransactionsForAddress(
+    addr: string,
+    token: string
+  ): Promise<Transaction[]> {
+    const { data: tokenTransactionsCount } = await network({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/transactions/count?token=${token}`,
+    });
+
+    let allTokenTransactions: Transaction[] = [];
+    let from = 0;
+    while (from <= tokenTransactionsCount) {
+      const { data: tokenTransactions } = await network({
+        method: "GET",
+        url: `${this.API_URL}/accounts/${addr}/transactions?token=${token}&from=${from}&size=${MAX_PAGINATION_SIZE}`,
+      });
+
+      allTokenTransactions = [...allTokenTransactions, ...tokenTransactions];
+
+      from = from + MAX_PAGINATION_SIZE;
+    }
+
+    for (const esdtTransaction of allTokenTransactions) {
+      esdtTransaction.transfer = ElrondTransferOptions.esdt;
+    }
+
+    return allTokenTransactions;
+  }
+
+  async getESDTTokensForAddress(addr: string): Promise<ESDTToken[]> {
+    const { data: tokensCount } = await network({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/tokens/count`,
+    });
+
+    let allTokens: ESDTToken[] = [];
+    let from = 0;
+    while (from <= tokensCount) {
+      const { data: tokens } = await network({
+        method: "GET",
+        url: `${this.API_URL}/accounts/${addr}/tokens?from=${from}&size=${MAX_PAGINATION_SIZE}`,
+      });
+
+      allTokens = [...allTokens, ...tokens];
+
+      from = from + MAX_PAGINATION_SIZE;
+    }
+
+    return allTokens;
+  }
+
+  async getESDTTokensCountForAddress(addr: string): Promise<number> {
+    const { data: tokensCount } = await network({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/tokens/count`,
+    });
+
+    return tokensCount;
+  }
+
+  async getBlockchainBlockHeight(): Promise<number> {
     const {
       data: [{ round: blockHeight }],
     } = await network({

src/families/elrond/api/index.ts

@@ -5,4 +5,7 @@ export {
   getOperations,
   getFees,
   broadcastTransaction,
+  getAccountESDTTokens,
+  getAccountESDTOperations,
+  hasESDTTokens,
 } from "./sdk";

src/families/elrond/api/sdk.ts

@@ -1,10 +1,16 @@
 import { BigNumber } from "bignumber.js";
 import ElrondApi from "./apiCalls";
-import type { Transaction } from "../types";
+import {
+  ElrondTransferOptions,
+  ESDTToken,
+  NetworkInfo,
+  Transaction,
+} from "../types";
 import type { Operation, OperationType } from "../../../types";
 import { getEnv } from "../../../env";
 import { encodeOperationId } from "../../../operation";
 import { getTransactionParams } from "../cache";
+import { ESDT_TRANSFER_GAS } from "../constants";
 const api = new ElrondApi(getEnv("ELROND_API_ENDPOINT"));
 
 /**
@@ -19,13 +25,15 @@ export const getAccount = async (addr: string) => {
     nonce,
   };
 };
+
 export const getValidators = async () => {
   const validators = await api.getValidators();
   return {
     validators,
   };
 };
-export const getNetworkConfig = async () => {
+
+export const getNetworkConfig = async (): Promise<NetworkInfo> => {
   return await api.getNetworkConfig();
 };
 
@@ -50,9 +58,15 @@ function getOperationType(
  * Map transaction to a correct Operation Value (affecting account balance)
  */
 function getOperationValue(transaction: Transaction, addr: string): BigNumber {
-  return isSender(transaction, addr)
-    ? new BigNumber(transaction.value ?? 0).plus(transaction.fee ?? 0)
-    : new BigNumber(transaction.value ?? 0);
+  if (transaction.transfer === ElrondTransferOptions.esdt) {
+    return new BigNumber(transaction.tokenValue ?? 0);
+  }
+
+  if (!isSender(transaction, addr)) {
+    return new BigNumber(transaction.value ?? 0);
+  }
+
+  return new BigNumber(transaction.value ?? 0).plus(transaction.fee ?? 0);
 }
 
 /**
@@ -102,25 +116,75 @@ export const getOperations = async (
   );
 };
 
+export const getAccountESDTTokens = async (
+  address: string
+): Promise<ESDTToken[]> => {
+  return await api.getESDTTokensForAddress(address);
+};
+
+export const hasESDTTokens = async (address: string): Promise<boolean> => {
+  const tokensCount = await api.getESDTTokensCountForAddress(address);
+  return tokensCount > 0;
+};
+
+export const getAccountESDTOperations = async (
+  accountId: string,
+  address: string,
+  tokenIdentifier: string
+): Promise<Operation[]> => {
+  const accountESDTTransactions = await api.getESDTTransactionsForAddress(
+    address,
+    tokenIdentifier
+  );
+
+  return accountESDTTransactions.map((transaction) =>
+    transactionToOperation(accountId, address, transaction)
+  );
+};
+
 /**
  * Obtain fees from blockchain
  */
-export const getFees = async (unsigned): Promise<BigNumber> => {
-  const { data } = unsigned;
-  const { gasLimit, gasPerByte, gasPrice } = await getTransactionParams();
+export const getFees = async (t: Transaction): Promise<BigNumber> => {
+  const transactionParams = await getTransactionParams();
+  const {
+    gasPerByte,
+    gasPriceModifier,
+    gasLimit: minGasLimit,
+  } = transactionParams;
+  let gasPrice = transactionParams.gasPrice;
+
+  let gasLimit = minGasLimit;
+  if (t.subAccountId) {
+    gasLimit = ESDT_TRANSFER_GAS;
+  }
 
-  if (!data) {
-    return new BigNumber(gasLimit * gasPrice);
+  const transactionData = Buffer.from(t.data?.trim() || []);
+
+  const moveBalanceGas = minGasLimit + transactionData.length * gasPerByte;
+
+  if (t.subAccountId) {
+    gasLimit = ESDT_TRANSFER_GAS;
+  }
+
+  gasPrice = new BigNumber(gasPrice);
+  const feeForMove = new BigNumber(moveBalanceGas).multipliedBy(gasPrice);
+  if (moveBalanceGas === gasLimit) {
+    return feeForMove;
   }
 
-  return new BigNumber((gasLimit + gasPerByte * data.length) * gasPrice);
+  const diff = new BigNumber(gasLimit - moveBalanceGas);
+  const modifiedGasPrice = gasPrice.multipliedBy(
+    new BigNumber(gasPriceModifier)
+  );
+  const processingFee = diff.multipliedBy(modifiedGasPrice);
+
+  return feeForMove.plus(processingFee);
 };
 
 /**
  * Broadcast blob to blockchain
  */
-export const broadcastTransaction = async (blob: any) => {
-  const { hash } = await api.submit(blob);
-  // Transaction hash is likely to be returned
-  return hash;
+export const broadcastTransaction = async (blob: any): Promise<string> => {
+  return await api.submit(blob);
 };

src/families/elrond/constants.ts

@@ -3,4 +3,6 @@ export const HASH_TRANSACTION = {
   options: 1,
 };
 export const METACHAIN_SHARD = 4294967295;
-export const TRANSACTIONS_SIZE = 10000;
+export const MAX_PAGINATION_SIZE = 10000;
+export const ESDT_TRANSFER_GAS = 500000;
+export const CHAIN_ID = "1";