@ledgerhq/coin-multiversx 0.2.0-next.0

package/src/synchronisation.ts

@@ -0,0 +1,74 @@
+import { TokenAccount } from "@ledgerhq/types-live";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { makeSync, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
+import { getAccount, getAccountDelegations, getEGLDOperations, hasESDTTokens } from "./api";
+import MultiversXBuildESDTTokenAccounts from "./buildSubAccounts";
+import { reconciliateSubAccounts } from "./reconciliation";
+import { computeDelegationBalance } from "./logic";
+import { MultiversXAccount } from "./types";
+
+export const getAccountShape: GetAccountShape<MultiversXAccount> = async (info, syncConfig) => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const oldOperations = initialAccount?.operations || [];
+  // Needed for incremental synchronisation
+  const startAt = oldOperations.length ? Math.floor(oldOperations[0].date.valueOf() / 1000) : 0;
+
+  const account = await getAccount(address);
+
+  const delegations = await getAccountDelegations(address);
+
+  let subAccounts: TokenAccount[] = [];
+  const hasTokens = await hasESDTTokens(address);
+  if (hasTokens) {
+    const tokenAccounts = await MultiversXBuildESDTTokenAccounts({
+      currency,
+      accountId: accountId,
+      accountAddress: address,
+      existingAccount: initialAccount,
+      syncConfig,
+    });
+
+    if (tokenAccounts) {
+      subAccounts = reconciliateSubAccounts(tokenAccounts, initialAccount);
+    }
+  }
+
+  const delegationBalance = computeDelegationBalance(delegations);
+
+  // Merge new operations with the previously synced ones
+  const newOperations = await getEGLDOperations(accountId, address, startAt, subAccounts);
+  const operations = mergeOps(oldOperations, newOperations);
+
+  return {
+    id: accountId,
+    balance: account.balance.plus(delegationBalance),
+    spendableBalance: account.balance,
+    operationsCount: operations.length,
+    blockHeight: account.blockHeight,
+    multiversxResources: {
+      nonce: account.nonce,
+      delegations,
+      isGuarded: account.isGuarded,
+    },
+    subAccounts,
+    operations: operations.map(op => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
+
+      return {
+        ...op,
+        subOperations,
+      };
+    }),
+  };
+};
+
+export const sync = makeSync({ getAccountShape });

package/src/transaction.ts

@@ -0,0 +1,76 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+
+export const formatTransaction = (
+  { mode, amount, recipient, useAllAmount, subAccountId }: Transaction,
+  mainAccount: Account,
+): string => {
+  const account =
+    (subAccountId && (mainAccount.subAccounts || []).find(a => a.id === subAccountId)) ||
+    mainAccount;
+  return `
+${mode.toUpperCase()} ${
+    useAllAmount
+      ? "MAX"
+      : amount.isZero()
+        ? ""
+        : " " +
+          formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+            showCode: true,
+            disableRounding: true,
+          })
+  }${recipient ? `\nTO ${recipient}` : ""}`;
+};
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  const tx: Transaction = {
+    ...common,
+    family: tr.family,
+    mode: tr.mode,
+    fees: tr.fees ? new BigNumber(tr.fees) : null,
+    gasLimit: tr.gasLimit,
+  };
+
+  if (tr.data) {
+    tx.data = tr.data;
+  }
+
+  return tx;
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  const tx: TransactionRaw = {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    fees: t.fees?.toString() || null,
+    gasLimit: t.gasLimit,
+  };
+
+  if (t.data) {
+    tx.data = t.data;
+  }
+
+  return tx;
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/types.ts

@@ -0,0 +1,235 @@
+import type {
+  Account,
+  AccountRaw,
+  Operation,
+  OperationExtra,
+  OperationExtraRaw,
+  OperationRaw,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+export type MultiversXAccount = Account & { multiversxResources: MultiversXResources };
+
+export type MultiversXAccountRaw = AccountRaw & {
+  multiversxResources: MultiversXResourcesRaw;
+};
+
+export type MultiversXResources = {
+  nonce: number;
+  delegations: MultiversXDelegation[];
+  isGuarded: boolean;
+};
+
+export type MultiversXResourcesRaw = {
+  nonce: number;
+  delegations: MultiversXDelegation[];
+  isGuarded: boolean;
+};
+
+export type MultiversXDelegation = {
+  address: string;
+  contract: string;
+  userUnBondable: string;
+  userActiveStake: string;
+  claimableRewards: string;
+  userUndelegatedList: UserUndelegated[];
+};
+
+export type UserUndelegated = {
+  amount: string;
+  seconds: number;
+};
+
+/**
+ * MultiversX transaction
+ */
+export type Transaction = TransactionCommon & {
+  family: "multiversx";
+  mode: MultiversXTransactionMode;
+  fees: BigNumber | null | undefined;
+  data?: string;
+  gasLimit: number;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "multiversx";
+  mode: MultiversXTransactionMode;
+  fees: string | null | undefined;
+  data?: string;
+  gasLimit: number;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type MultiversXTransactionMode =
+  | "send"
+  | "delegate"
+  | "reDelegateRewards"
+  | "unDelegate"
+  | "claimRewards"
+  | "withdraw";
+
+/**
+ * MultiversX transaction payload to sign
+ */
+export type MultiversXProtocolTransaction = {
+  nonce: number;
+  value: string;
+  receiver: string;
+  sender: string;
+  gasPrice: number;
+  gasLimit: number;
+  chainID: string;
+  signature?: string;
+  data?: string; //for ESDT or stake transactions
+  version: number;
+  options: number;
+};
+
+/**
+ * MultiversX transaction as received from explorer
+ */
+export type MultiversXApiTransaction = {
+  mode: MultiversXTransactionMode;
+  fees: BigNumber | null | undefined;
+  transfer?: MultiversXTransferOptions;
+  txHash?: string;
+  sender?: string;
+  receiver?: string;
+  value?: BigNumber;
+  blockHash?: string;
+  blockHeight?: number;
+  timestamp?: number;
+  nonce?: number;
+  gasLimit: number;
+  status?: string;
+  fee?: BigNumber;
+  round?: number;
+  miniBlockHash?: string;
+  data?: string;
+  tokenIdentifier?: string;
+  tokenValue?: string;
+  action?: MultiversXTransactionAction;
+  operations?: MultiversXTransactionOperation[];
+};
+
+export enum MultiversXTransferOptions {
+  egld = "egld",
+  esdt = "esdt",
+}
+
+export type MultiversXTransactionOperation = {
+  action: string;
+  type: string;
+  sender: string;
+  receiver: string;
+  value: string;
+};
+
+export type MultiversXTransactionAction = {
+  category: string;
+  name: string;
+  arguments: MultiversXTransactionActionArguments;
+};
+
+export type MultiversXTransactionActionArguments = {
+  transfers: MultiversXTransactionActionArgumentsTransfers[];
+};
+
+export type MultiversXTransactionActionArgumentsTransfers = {
+  token: string;
+  value: string;
+};
+
+export type ESDTToken = {
+  identifier: string;
+  name: string;
+  balance: string;
+};
+
+export type NetworkInfo = {
+  family?: "multiversx";
+  chainID: string;
+  denomination: number;
+  gasLimit: number;
+  gasPrice: number;
+  gasPerByte: number;
+  gasPriceModifier: string;
+};
+
+export type NetworkInfoRaw = {
+  family?: "multiversx";
+  chainID: string;
+  denomination: number;
+  gasLimit: number;
+  gasPrice: number;
+  gasPerByte: number;
+};
+
+export type MultiversXPreloadData = {
+  validators: MultiversXProvider[];
+};
+
+/**
+ * MultiversX validator
+ */
+export type MultiversXProvider = {
+  contract: string;
+  owner: string;
+  serviceFee: string;
+  maxDelegationCap: string;
+  initialOwnerFunds: string;
+  totalActiveStake: string;
+  totalUnstaked: string;
+  maxDelegateAmountAllowed: string;
+  apr: string;
+  explorerURL: string;
+  address: string;
+  aprValue: number;
+  automaticActivation: boolean;
+  changeableServiceFee: boolean;
+  checkCapOnRedelegate: boolean;
+  createdNonce: number;
+  featured: boolean;
+  numNodes: number;
+  numUsers: number;
+  ownerBelowRequiredBalanceThreshold: boolean;
+  unBondPeriod: number;
+  withDelegationCap: boolean;
+  disabled?: boolean;
+  identity: {
+    key: string;
+    name: string;
+    avatar: string;
+    description: string;
+    location?: string;
+    twitter: string;
+    url: string;
+  };
+};
+
+export type MultiversXOperation = Operation<MultiversXOperationExtra>;
+export type MultiversXOperationRaw = OperationRaw<MultiversXOperationExtraRaw>;
+
+export type MultiversXOperationExtra = {
+  amount?: BigNumber;
+};
+
+export function isMultiversXOperationExtra(op: OperationExtra): op is MultiversXOperationExtra {
+  return op !== null && typeof op === "object" && "amount" in op;
+}
+
+export type MultiversXOperationExtraRaw = {
+  amount?: string;
+};
+export function isMultiversXOperationExtraRaw(
+  op: OperationExtraRaw,
+): op is MultiversXOperationExtraRaw {
+  return op !== null && typeof op === "object" && "amount" in op;
+}

package/src/utils/binary.utils.ts

@@ -0,0 +1,13 @@
+function base64DecodeBinary(str: string): Buffer {
+  return Buffer.from(str, "base64");
+}
+
+export class BinaryUtils {
+  static base64Encode(str: string): string {
+    return Buffer.from(str).toString("base64");
+  }
+
+  static base64Decode(str: string): string {
+    return base64DecodeBinary(str).toString("binary");
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "rootDir": "./src",
+    "outDir": "lib",
+    "exactOptionalPropertyTypes": true
+  },
+  "include": ["src/**/*"]
+}