@ledgerhq/coin-multiversx 0.2.0-next.0

package/src/api/apiCalls.ts

@@ -0,0 +1,243 @@
+import network from "@ledgerhq/live-network";
+import { SignedOperation } from "@ledgerhq/types-live/src";
+import { MAX_PAGINATION_SIZE, METACHAIN_SHARD } from "../constants";
+import {
+  ESDTToken,
+  MultiversXApiTransaction,
+  MultiversXDelegation,
+  MultiversXProvider,
+  MultiversXTransactionAction,
+  MultiversXTransactionMode,
+  MultiversXTransferOptions,
+  NetworkInfo,
+} from "../types";
+import { MultiversXAccount } from "./dtos/multiversx-account";
+
+interface NetworkInfoResponse {
+  data: {
+    config: {
+      erd_chain_id: string;
+      erd_denomination: number;
+      erd_min_gas_limit: number;
+      erd_min_gas_price: number;
+      erd_gas_per_data_byte: number;
+      erd_gas_price_modifier: string;
+    };
+  };
+}
+
+interface SubmitTransactionResponse {
+  data: {
+    txHash: string;
+  };
+}
+
+interface BlockRoundResponse {
+  round: number;
+}
+
+const decodeTransactionMode = (action?: MultiversXTransactionAction): string => {
+  if (!action) {
+    return "send";
+  }
+
+  if (!action.category) {
+    return "send";
+  }
+
+  if (action.category !== "stake") {
+    return "send";
+  }
+
+  const mode = action.name;
+
+  return mode;
+};
+
+export default class MultiversXApi {
+  private API_URL: string;
+  private DELEGATION_API_URL: string;
+
+  constructor(API_URL: string, DELEGATION_API_URL: string) {
+    this.API_URL = API_URL;
+    this.DELEGATION_API_URL = DELEGATION_API_URL;
+  }
+
+  async getAccountDetails(addr: string) {
+    const {
+      data: { balance, nonce, isGuarded },
+    } = await network<MultiversXAccount>({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}?withGuardianInfo=true`,
+    });
+
+    return {
+      balance,
+      nonce,
+      isGuarded,
+    };
+  }
+
+  async getProviders(): Promise<MultiversXProvider[]> {
+    const { data: providers } = await network<MultiversXProvider[]>({
+      method: "GET",
+      url: `${this.DELEGATION_API_URL}/providers`,
+    });
+
+    return providers;
+  }
+
+  async getNetworkConfig(): Promise<NetworkInfo> {
+    const {
+      data: {
+        data: {
+          config: {
+            erd_chain_id: chainId,
+            erd_denomination: denomination,
+            erd_min_gas_limit: gasLimit,
+            erd_min_gas_price: gasPrice,
+            erd_gas_per_data_byte: gasPerByte,
+            erd_gas_price_modifier: gasPriceModifier,
+          },
+        },
+      },
+    } = await network<NetworkInfoResponse>({
+      method: "GET",
+      url: `${this.API_URL}/network/config`,
+    });
+
+    return {
+      chainID: chainId,
+      denomination,
+      gasLimit,
+      gasPrice,
+      gasPerByte,
+      gasPriceModifier,
+    };
+  }
+
+  async submit(signedOperation: SignedOperation): Promise<string> {
+    const transaction = {
+      ...signedOperation.rawData,
+      signature: signedOperation.signature,
+    };
+
+    const {
+      data: {
+        data: { txHash: hash },
+      },
+    } = await network<SubmitTransactionResponse>({
+      method: "POST",
+      url: `${this.API_URL}/transaction/send`,
+      data: transaction,
+    });
+
+    return hash;
+  }
+
+  async getHistory(addr: string, startAt: number): Promise<MultiversXApiTransaction[]> {
+    const { data: transactionsCount } = await network<number>({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/transactions/count?after=${startAt}`,
+    });
+
+    let allTransactions: MultiversXApiTransaction[] = [];
+    let from = 0;
+    while (from < transactionsCount) {
+      const { data: transactions } = await network<MultiversXApiTransaction[]>({
+        method: "GET",
+        url: `${this.API_URL}/accounts/${addr}/transactions?after=${startAt}&from=${from}&size=${MAX_PAGINATION_SIZE}&withOperations=true&withScResults=true`,
+      });
+
+      for (const transaction of transactions) {
+        transaction.mode = decodeTransactionMode(transaction.action) as MultiversXTransactionMode;
+      }
+
+      allTransactions = [...allTransactions, ...transactions];
+
+      from = from + MAX_PAGINATION_SIZE;
+    }
+
+    return allTransactions;
+  }
+
+  async getAccountDelegations(addr: string): Promise<MultiversXDelegation[]> {
+    const { data: delegations } = await network<MultiversXDelegation[]>({
+      method: "GET",
+      url: `${this.DELEGATION_API_URL}/accounts/${addr}/delegations`,
+    });
+
+    return delegations;
+  }
+
+  async getESDTTransactionsForAddress(
+    addr: string,
+    token: string,
+    startAt: number,
+  ): Promise<MultiversXApiTransaction[]> {
+    const { data: tokenTransactionsCount } = await network<number>({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/transactions/count?token=${token}&after=${startAt}`,
+    });
+
+    let allTokenTransactions: MultiversXApiTransaction[] = [];
+    let from = 0;
+    while (from < tokenTransactionsCount) {
+      const { data: tokenTransactions } = await network<MultiversXApiTransaction[]>({
+        method: "GET",
+        url: `${this.API_URL}/accounts/${addr}/transactions?token=${token}&from=${from}&after=${startAt}&size=${MAX_PAGINATION_SIZE}`,
+      });
+
+      allTokenTransactions = [...allTokenTransactions, ...tokenTransactions];
+
+      from = from + MAX_PAGINATION_SIZE;
+    }
+
+    for (const esdtTransaction of allTokenTransactions) {
+      esdtTransaction.transfer = MultiversXTransferOptions.esdt;
+    }
+
+    return allTokenTransactions;
+  }
+
+  async getESDTTokensForAddress(addr: string): Promise<ESDTToken[]> {
+    const { data: tokensCount } = await network<number>({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/tokens/count`,
+    });
+
+    let allTokens: ESDTToken[] = [];
+    let from = 0;
+    while (from < tokensCount) {
+      const { data: tokens } = await network<ESDTToken[]>({
+        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<number>({
+      method: "GET",
+      url: `${this.API_URL}/accounts/${addr}/tokens/count`,
+    });
+
+    return tokensCount;
+  }
+
+  async getBlockchainBlockHeight(): Promise<number> {
+    const {
+      data: [{ round: blockHeight }],
+    } = await network<BlockRoundResponse[]>({
+      method: "GET",
+      url: `${this.API_URL}/blocks?shard=${METACHAIN_SHARD}&fields=round`,
+    });
+    return blockHeight;
+  }
+}

package/src/api/dtos/multiversx-account.ts

@@ -0,0 +1,20 @@
+import BigNumber from "bignumber.js";
+
+export class MultiversXAccount {
+  balance: BigNumber;
+  nonce: number;
+  isGuarded: boolean;
+  blockHeight: number;
+
+  constructor(
+    balance: BigNumber,
+    nonce: number,
+    isGuarded: boolean | null | undefined,
+    blockHeight: number,
+  ) {
+    this.balance = balance;
+    this.nonce = nonce;
+    this.isGuarded = isGuarded ? true : false;
+    this.blockHeight = blockHeight;
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,13 @@
+export {
+  getAccount,
+  getNetworkConfig,
+  getProviders,
+  getEGLDOperations,
+  getFees,
+  broadcastTransaction,
+  getAccountESDTTokens,
+  getAccountDelegations,
+  getESDTOperations,
+  hasESDTTokens,
+  getAccountNonce,
+} from "./sdk";

package/src/api/sdk.ts

@@ -0,0 +1,368 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import { getEnv } from "@ledgerhq/live-env";
+import type { OperationType, SignedOperation, TokenAccount } from "@ledgerhq/types-live";
+import {
+  Address,
+  ApiNetworkProvider,
+  INetworkConfig,
+  INonce,
+  Transaction as MultiversXSdkTransaction,
+  TransactionPayload,
+} from "@multiversx/sdk-core";
+import { BigNumber } from "bignumber.js";
+import {
+  CHAIN_ID,
+  GAS_PER_DATA_BYTE,
+  GAS_PRICE,
+  GAS_PRICE_MODIFIER,
+  MIN_GAS_LIMIT,
+  MULTIVERSX_STAKING_POOL,
+} from "../constants";
+import {
+  ESDTToken,
+  MultiversXApiTransaction,
+  MultiversXDelegation,
+  MultiversXOperation,
+  MultiversXProvider,
+  MultiversXTransactionOperation,
+  MultiversXTransferOptions,
+  Transaction,
+} from "../types";
+import { BinaryUtils } from "../utils/binary.utils";
+import MultiversXApi from "./apiCalls";
+import { MultiversXAccount } from "./dtos/multiversx-account";
+const api = new MultiversXApi(
+  getEnv("MULTIVERSX_API_ENDPOINT"),
+  getEnv("MULTIVERSX_DELEGATION_API_ENDPOINT"),
+);
+
+const networkConfig = { clientName: "ledger-live" };
+const proxy = new ApiNetworkProvider(getEnv("MULTIVERSX_API_ENDPOINT"), networkConfig);
+
+/**
+ * Get account balances and nonce
+ */
+export const getAccount = async (addr: string): Promise<MultiversXAccount> => {
+  const { balance, nonce, isGuarded } = await api.getAccountDetails(addr);
+  const blockHeight = await api.getBlockchainBlockHeight();
+
+  const account = new MultiversXAccount(new BigNumber(balance), nonce, isGuarded, blockHeight);
+  return account;
+};
+
+export const getProviders = async (): Promise<MultiversXProvider[]> => {
+  const providers = await api.getProviders();
+  return providers;
+};
+
+export const getNetworkConfig = async (): Promise<INetworkConfig> => {
+  return await proxy.getNetworkConfig();
+};
+
+export const getAccountNonce = async (addr: string): Promise<INonce> => {
+  const address = new Address(addr);
+
+  const account = await proxy.getAccount(address);
+
+  return account.nonce;
+};
+
+/**
+ * Returns true if account is the signer
+ */
+function isSender(transaction: MultiversXApiTransaction, addr: string): boolean {
+  return transaction.sender === addr;
+}
+
+function isSelfSend(transaction: MultiversXApiTransaction): boolean {
+  return (
+    !!transaction.sender && !!transaction.receiver && transaction.sender === transaction.receiver
+  );
+}
+
+/**
+ * Map transaction to an Operation Type
+ */
+function getEGLDOperationType(transaction: MultiversXApiTransaction, addr: string): OperationType {
+  if (transaction.action && transaction.action.category == "stake") {
+    const stakeAction = transaction.action.name;
+    switch (stakeAction) {
+      case "delegate":
+        return "DELEGATE";
+      case "unDelegate":
+        return "UNDELEGATE";
+      case "withdraw":
+        return "WITHDRAW_UNBONDED";
+      case "claimRewards":
+        return "REWARD";
+      case "reDelegateRewards":
+        return "DELEGATE";
+    }
+  }
+  return isSender(transaction, addr)
+    ? transaction.transfer === MultiversXTransferOptions.esdt
+      ? "FEES"
+      : "OUT"
+    : "IN";
+}
+
+function getESDTOperationValue(
+  transaction: MultiversXApiTransaction,
+  tokenIdentifier?: string,
+): BigNumber {
+  const hasFailed =
+    !transaction.status || transaction.status === "fail" || transaction.status === "invalid";
+
+  if (!transaction.action || hasFailed) {
+    return new BigNumber(0);
+  }
+  let token1, token2;
+  switch (transaction.action.name) {
+    case "transfer":
+      return new BigNumber(transaction.action.arguments.transfers[0].value ?? 0);
+    case "swap":
+      token1 = transaction.action.arguments.transfers[0];
+      token2 = transaction.action.arguments.transfers[1];
+      if (token1.token === tokenIdentifier) {
+        return new BigNumber(token1.value);
+      } else {
+        return new BigNumber(token2.value);
+      }
+    default:
+      return new BigNumber(transaction.tokenValue ?? 0);
+  }
+}
+
+function getStakingAmount(transaction: MultiversXApiTransaction, address: string): BigNumber {
+  const operation: MultiversXTransactionOperation | undefined = transaction.operations?.find(
+    ({ sender, receiver, action, type }) =>
+      action == "transfer" &&
+      type == "egld" &&
+      sender == transaction.receiver &&
+      (receiver == address || receiver == MULTIVERSX_STAKING_POOL),
+  );
+
+  let dataDecoded;
+  switch (transaction.mode) {
+    case "send":
+      return new BigNumber(0);
+    case "delegate":
+      return new BigNumber(transaction.value ?? 0);
+    case "unDelegate":
+      dataDecoded = BinaryUtils.base64Decode(transaction.data ?? "");
+      return new BigNumber(`0x${dataDecoded.split("@")[1]}`);
+    case "reDelegateRewards":
+    case "claimRewards":
+    case "withdraw":
+    default:
+      return new BigNumber(operation?.value ?? new BigNumber(0));
+  }
+}
+
+/**
+ * Map transaction to a correct Operation Value (affecting account balance)
+ */
+function getEGLDOperationValue(transaction: MultiversXApiTransaction, address: string): BigNumber {
+  if (transaction.mode === "send") {
+    if (transaction.transfer === MultiversXTransferOptions.esdt) {
+      // Only fees paid in EGLD for token transactions
+      return isSender(transaction, address) && transaction.fee
+        ? new BigNumber(transaction.fee)
+        : new BigNumber(0);
+    } else {
+      return isSender(transaction, address)
+        ? isSelfSend(transaction)
+          ? new BigNumber(transaction.fee ?? 0) // Self-send, only fees are paid
+          : new BigNumber(transaction.value ?? 0).plus(transaction.fee ?? 0) // The sender pays the amount and the fees
+        : new BigNumber(transaction.value ?? 0); // The recipient gets the amount
+    }
+  } else {
+    // Operation value for staking transactions are just the fees, plus possible rewards
+    // Other amounts are put in extra.amount
+    return new BigNumber(transaction.fee ?? 0);
+  }
+}
+
+/**
+ * Map the MultiversX history transaction to a Ledger Live Operation
+ */
+function transactionToEGLDOperation(
+  accountId: string,
+  addr: string,
+  transaction: MultiversXApiTransaction,
+  subAccounts: TokenAccount[],
+): MultiversXOperation {
+  const type = getEGLDOperationType(transaction, addr);
+  const fee = new BigNumber(transaction.fee ?? 0);
+  const hasFailed =
+    !transaction.status || transaction.status === "fail" || transaction.status === "invalid";
+
+  const delegationAmount = getStakingAmount(transaction, addr);
+
+  const value = hasFailed
+    ? isSender(transaction, addr)
+      ? fee
+      : new BigNumber(0)
+    : transaction.mode === "claimRewards"
+      ? delegationAmount.minus(fee)
+      : getEGLDOperationValue(transaction, addr);
+
+  const operation: MultiversXOperation = {
+    id: encodeOperationId(accountId, transaction.txHash ?? "", type),
+    accountId,
+    fee,
+    value,
+    type,
+    hash: transaction.txHash ?? "",
+    blockHash: transaction.miniBlockHash,
+    blockHeight: transaction.round,
+    date: new Date(transaction.timestamp ? transaction.timestamp * 1000 : 0),
+    extra: {
+      amount: delegationAmount,
+    },
+    senders: (type == "OUT" || type == "IN") && transaction.sender ? [transaction.sender] : [],
+    recipients:
+      (type == "OUT" || type == "IN") && transaction.receiver ? [transaction.receiver] : [],
+    transactionSequenceNumber: isSender(transaction, addr) ? transaction.nonce : undefined,
+    hasFailed,
+  };
+
+  const subOperations = subAccounts
+    ? inferSubOperations(transaction.txHash ?? "", subAccounts)
+    : undefined;
+
+  if (subOperations) {
+    operation.subOperations = subOperations;
+  }
+
+  let contract: string | undefined = undefined;
+  if (transaction.receiver) {
+    const isReceiverSmartContract = Address.newFromBech32(transaction.receiver).isSmartContract();
+
+    contract = isReceiverSmartContract ? transaction.receiver : undefined;
+  }
+
+  if (contract) {
+    operation.contract = contract;
+  }
+
+  return operation;
+}
+
+const getESDTOperationType = (
+  transaction: MultiversXApiTransaction,
+  address: string,
+): OperationType => {
+  return isSender(transaction, address) ? "OUT" : "IN";
+};
+
+const transactionToESDTOperation = (
+  tokenAccountId: string,
+  addr: string,
+  transaction: MultiversXApiTransaction,
+  tokenIdentifier?: string,
+): MultiversXOperation => {
+  const type = getESDTOperationType(transaction, addr);
+  const value = getESDTOperationValue(transaction, tokenIdentifier);
+  const fee = new BigNumber(transaction.fee ?? 0);
+  const senders: string[] = transaction.sender ? [transaction.sender] : [];
+  const recipients: string[] = transaction.receiver ? [transaction.receiver] : [];
+  const hash = transaction.txHash ?? "";
+  const blockHeight = transaction.round;
+  const date = new Date(transaction.timestamp ? transaction.timestamp * 1000 : 0);
+
+  return {
+    id: encodeOperationId(tokenAccountId, hash, type),
+    accountId: tokenAccountId,
+    hash,
+    date,
+    type,
+    value,
+    fee,
+    senders,
+    recipients,
+    blockHeight,
+    blockHash: transaction.miniBlockHash,
+    extra: {},
+  };
+};
+
+/**
+ * Fetch operation list
+ */
+export const getEGLDOperations = async (
+  accountId: string,
+  addr: string,
+  startAt: number,
+  subAccounts: TokenAccount[],
+): Promise<MultiversXOperation[]> => {
+  const rawTransactions = await api.getHistory(addr, startAt);
+  if (!rawTransactions) return rawTransactions;
+  return rawTransactions.map(transaction =>
+    transactionToEGLDOperation(accountId, addr, transaction, subAccounts),
+  );
+};
+
+export const getAccountESDTTokens = async (address: string): Promise<ESDTToken[]> => {
+  return await api.getESDTTokensForAddress(address);
+};
+
+export const getAccountDelegations = async (address: string): Promise<MultiversXDelegation[]> => {
+  return await api.getAccountDelegations(address);
+};
+
+export const hasESDTTokens = async (address: string): Promise<boolean> => {
+  const tokensCount = await api.getESDTTokensCountForAddress(address);
+  return tokensCount > 0;
+};
+
+export const getESDTOperations = async (
+  tokenAccountId: string,
+  address: string,
+  tokenIdentifier: string,
+  startAt: number,
+): Promise<MultiversXOperation[]> => {
+  const accountESDTTransactions = await api.getESDTTransactionsForAddress(
+    address,
+    tokenIdentifier,
+    startAt,
+  );
+
+  return accountESDTTransactions.map(transaction =>
+    transactionToESDTOperation(tokenAccountId, address, transaction, tokenIdentifier),
+  );
+};
+
+/**
+ * Obtain fees from blockchain
+ */
+export const getFees = async (t: Transaction): Promise<BigNumber> => {
+  const networkConfig: INetworkConfig = {
+    MinGasLimit: MIN_GAS_LIMIT,
+    GasPerDataByte: GAS_PER_DATA_BYTE,
+    GasPriceModifier: GAS_PRICE_MODIFIER,
+    ChainID: CHAIN_ID,
+  };
+
+  const transaction = new MultiversXSdkTransaction({
+    data: TransactionPayload.fromEncoded(t.data?.trim()),
+    receiver: new Address(getAbandonSeedAddress("elrond")),
+    chainID: CHAIN_ID,
+    gasPrice: GAS_PRICE,
+    gasLimit: t.gasLimit ?? networkConfig.MinGasLimit,
+    sender: Address.empty(),
+  });
+
+  const feesStr = transaction.computeFee(networkConfig).toFixed();
+
+  return new BigNumber(feesStr);
+};
+
+/**
+ * Broadcast blob to blockchain
+ */
+export const broadcastTransaction = async (signedOperation: SignedOperation): Promise<string> => {
+  return await api.submit(signedOperation);
+};