@ledgerhq/coin-multiversx 0.2.0-next.0

package/src/helpers/handleTransactionStatus.ts

@@ -0,0 +1,26 @@
+import type { TransactionStatus } from "../types";
+
+/*
+ * Declare the type for the return payload of the transaction status handler.
+ */
+
+export interface handleTransactionStatusType {
+  warning: Error | false;
+  error: Error | false;
+}
+
+/*
+ * Return an object, of the function, with the error and warning keys, as boolean values.
+ */
+
+export const handleTransactionStatus = (status: TransactionStatus): handleTransactionStatusType => {
+  const [[warning], [error]] = [
+    Object.keys(status.warnings || {}),
+    Object.keys(status.errors || {}),
+  ];
+
+  return {
+    warning: status.warnings[warning],
+    error: status.errors[error],
+  };
+};

package/src/helpers/hasMinimumDelegableBalance.ts

@@ -0,0 +1,6 @@
+import { Account } from "@ledgerhq/types-live";
+
+import { MIN_DELEGATION_AMOUNT } from "../constants";
+
+export const hasMinimumDelegableBalance = (account: Account) =>
+  account.spendableBalance.isGreaterThanOrEqualTo(MIN_DELEGATION_AMOUNT);

package/src/helpers/randomizeProviders.ts

@@ -0,0 +1,20 @@
+import type { MultiversXProvider } from "../types";
+
+/*
+ * Declare the type for the extended validator object that has the sort key attached.
+ */
+
+export interface SortedValidatorType {
+  provider: MultiversXProvider;
+  sort: number;
+}
+
+/*
+ * Map through the providers, assign a random number, sort by that, then return the original providers' list.
+ */
+
+export const randomizeProviders = (providers: MultiversXProvider[]) =>
+  providers
+    .map(provider => ({ provider, sort: Math.random() }))
+    .sort((alpha: SortedValidatorType, beta: SortedValidatorType) => alpha.sort - beta.sort)
+    .map((item: SortedValidatorType) => item.provider);

package/src/hw-getAddress.ts

@@ -0,0 +1,19 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { MultiversXSigner } from "./signer";
+
+const resolver = (signerContext: SignerContext<MultiversXSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const { address, publicKey } = await signerContext(deviceId, signer =>
+      signer.getAddress(path, verify || false),
+    );
+    return {
+      address: address,
+      publicKey: publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/logic.ts

@@ -0,0 +1,83 @@
+import { decode, fromWords } from "bech32";
+import BigNumber from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
+import type { Transaction, MultiversXTransactionMode, MultiversXDelegation } from "./types";
+
+/**
+ * The human-readable-part of the bech32 addresses.
+ */
+const HRP = "erd";
+
+/**
+ * The length (in bytes) of a public key (from which a bech32 address can be obtained).
+ */
+const PUBKEY_LENGTH = 32;
+
+function fromBech32(value: string): string {
+  let decoded;
+
+  try {
+    decoded = decode(value);
+  } catch (err) {
+    throw new Error("Erd address can't be created");
+  }
+
+  const prefix = decoded.prefix;
+  if (prefix != HRP) {
+    throw new Error("Bad HRP");
+  }
+
+  const pubkey = Buffer.from(fromWords(decoded.words));
+  if (pubkey.length != PUBKEY_LENGTH) {
+    throw new Error("Erd address can't be created");
+  }
+
+  return value;
+}
+
+/**
+ * Returns true if address is a valid bech32
+ *
+ * @param {string} address
+ */
+export const isValidAddress = (address: string): boolean => {
+  try {
+    fromBech32(address);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+export const isSelfTransaction = (a: Account, t: Transaction): boolean => {
+  return t.recipient === a.freshAddress;
+};
+
+// For some transaction modes the amount doesn't belong to the account's balance
+export const isAmountSpentFromBalance = (mode: MultiversXTransactionMode) => {
+  return ["send", "delegate"].includes(mode);
+};
+
+export const computeDelegationBalance = (delegations: MultiversXDelegation[]): BigNumber => {
+  let totalDelegationBalance = new BigNumber(0);
+
+  for (const delegation of delegations) {
+    let delegationBalance = new BigNumber(delegation.userActiveStake).plus(
+      new BigNumber(delegation.claimableRewards),
+    );
+
+    for (const undelegation of delegation.userUndelegatedList) {
+      delegationBalance = delegationBalance.plus(new BigNumber(undelegation.amount));
+    }
+
+    totalDelegationBalance = totalDelegationBalance.plus(delegationBalance);
+  }
+
+  return totalDelegationBalance;
+};
+
+export const addPrefixToken = (tokenId: string) => `multiversx/esdt/${tokenId}`;
+
+export const extractTokenId = (tokenId: string) => {
+  return tokenId.split("/")[2];
+};

package/src/preload.ts

@@ -0,0 +1,95 @@
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import type { MultiversXPreloadData, MultiversXProvider } from "./types";
+import { getProviders } from "./api";
+const PRELOAD_MAX_AGE = 30 * 60 * 1000; // 30 minutes
+
+let currentPreloadedData: MultiversXPreloadData = {
+  validators: [],
+};
+
+function fromHydrateValidator(validatorRaw: Record<string, any>): MultiversXProvider {
+  return {
+    contract: validatorRaw.contract,
+    owner: validatorRaw.owner,
+    serviceFee: validatorRaw.serviceFee,
+    maxDelegationCap: validatorRaw.maxDelegationCap,
+    initialOwnerFunds: validatorRaw.initialOwnerFunds,
+    totalActiveStake: validatorRaw.totalActiveStake,
+    totalUnstaked: validatorRaw.totalUnstaked,
+    maxDelegateAmountAllowed: validatorRaw.maxDelegateAmountAllowed,
+    apr: validatorRaw.apr,
+    explorerURL: validatorRaw.explorerURL,
+    address: validatorRaw.address,
+    aprValue: Number(validatorRaw.aprValue),
+    automaticActivation: !!validatorRaw.automaticActivation,
+    changeableServiceFee: !!validatorRaw.changeableServiceFee,
+    checkCapOnRedelegate: !!validatorRaw.checkCapOnRedelegate,
+    createdNonce: Number(validatorRaw.createdNonce),
+    featured: !!validatorRaw.featured,
+    numNodes: Number(validatorRaw.numNodes),
+    numUsers: Number(validatorRaw.numUsers),
+    ownerBelowRequiredBalanceThreshold: !!validatorRaw.ownerBelowRequiredBalanceThreshold,
+    unBondPeriod: Number(validatorRaw.unBondPeriod),
+    withDelegationCap: !!validatorRaw.withDelegationCap,
+    disabled: !!validatorRaw.disabled,
+    identity: {
+      key: validatorRaw.identity.key,
+      name: validatorRaw.identity.name,
+      avatar: validatorRaw.identity.avatar,
+      description: validatorRaw.identity.description,
+      location: validatorRaw.identity.location === null ? null : validatorRaw.location,
+      twitter: validatorRaw.identity.twitter,
+      url: validatorRaw.identity.url,
+    },
+  };
+}
+
+function fromHydratePreloadData(data: any): MultiversXPreloadData {
+  let validators = [];
+
+  if (typeof data === "object" && data) {
+    if (Array.isArray(data.validators)) {
+      validators = data.validators.map(fromHydrateValidator);
+    }
+  }
+
+  return {
+    validators,
+  };
+}
+
+const updates = new Subject<MultiversXPreloadData>();
+export function getCurrentMultiversXPreloadData(): MultiversXPreloadData {
+  return currentPreloadedData;
+}
+
+export function setMultiversXPreloadData(data: MultiversXPreloadData) {
+  if (data === currentPreloadedData) return;
+  currentPreloadedData = data;
+  updates.next(data);
+}
+
+export function getMultiversXPreloadDataUpdates(): Observable<MultiversXPreloadData> {
+  return updates.asObservable();
+}
+
+export const getPreloadStrategy = () => {
+  return {
+    preloadMaxAge: PRELOAD_MAX_AGE,
+  };
+};
+
+export const preload = async (): Promise<MultiversXPreloadData> => {
+  log("multiversx/preload", "preloading multiversx data...");
+  const validators = (await getProviders()) || [];
+  return {
+    validators,
+  };
+};
+
+export const hydrate = (data: unknown) => {
+  const hydrated = fromHydratePreloadData(data);
+  log("multiversx/preload", `hydrated ${hydrated.validators.length} multiversx validators`);
+  setMultiversXPreloadData(hydrated);
+};

package/src/prepareTransaction.ts

@@ -0,0 +1,78 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+import { getFees } from "./api";
+import { GAS } from "./constants";
+import { MultiversXEncodeTransaction } from "./encode";
+import { isAmountSpentFromBalance } from "./logic";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+/**
+ * Prepare t before checking status
+ *
+ * @param {MultiversXAccount} account
+ * @param {Transaction} transaction
+ */
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  // What's the point of this extra variable ?
+  const preparedTx = transaction;
+
+  const tokenAccount =
+    (transaction.subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === transaction.subAccountId)) ||
+    null;
+
+  if (tokenAccount) {
+    preparedTx.data = MultiversXEncodeTransaction.ESDTTransfer(transaction, tokenAccount);
+    preparedTx.gasLimit = GAS.ESDT_TRANSFER;
+  } else {
+    switch (transaction.mode) {
+      case "delegate":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = MultiversXEncodeTransaction.delegate();
+        break;
+      case "claimRewards":
+        preparedTx.gasLimit = GAS.CLAIM;
+        preparedTx.data = MultiversXEncodeTransaction.claimRewards();
+        break;
+      case "withdraw":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = MultiversXEncodeTransaction.withdraw();
+        break;
+      case "reDelegateRewards":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = MultiversXEncodeTransaction.reDelegateRewards();
+        break;
+      case "unDelegate":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = MultiversXEncodeTransaction.unDelegate(transaction);
+        break;
+      case "send":
+        break;
+      default:
+        throw new Error("Unsupported transaction mode: " + transaction.mode);
+    }
+  }
+
+  if (transaction.useAllAmount) {
+    // Set the max amount
+    preparedTx.amount = tokenAccount ? tokenAccount.balance : account.spendableBalance;
+
+    // Compute estimated fees for that amount
+    preparedTx.fees = await getFees(preparedTx);
+
+    // Adjust max amount according to computed fees
+    if (!tokenAccount && isAmountSpentFromBalance(transaction.mode)) {
+      preparedTx.amount = preparedTx.amount.gt(preparedTx.fees)
+        ? preparedTx.amount.minus(preparedTx.fees)
+        : new BigNumber(0);
+    }
+  } else {
+    preparedTx.fees = await getFees(preparedTx);
+  }
+
+  return preparedTx;
+};

package/src/reconciliation.ts

@@ -0,0 +1,64 @@
+import { log } from "@ledgerhq/logs";
+import { Account, SubAccount, TokenAccount } from "@ledgerhq/types-live";
+
+export function reconciliateSubAccounts(
+  tokenAccounts: TokenAccount[],
+  initialAccount: Account | undefined,
+): TokenAccount[] {
+  let subAccounts;
+
+  if (initialAccount) {
+    const initialSubAccounts: SubAccount[] | undefined = initialAccount.subAccounts;
+    let anySubAccountHaveChanged = false;
+    const stats: string[] = [];
+
+    if (initialSubAccounts && tokenAccounts.length !== initialSubAccounts.length) {
+      stats.push("length differ");
+      anySubAccountHaveChanged = true;
+    }
+
+    subAccounts = tokenAccounts.map((ta: TokenAccount) => {
+      const existingTokenAccount = initialSubAccounts?.find(a => a.id === ta.id);
+
+      if (existingTokenAccount) {
+        let sameProperties = true;
+
+        if (existingTokenAccount !== ta) {
+          for (const property in existingTokenAccount) {
+            if ((existingTokenAccount as any)[property] !== (ta as any)[property]) {
+              sameProperties = false;
+              stats.push(`field ${property} changed for ${ta.id}`);
+              break;
+            }
+          }
+        }
+
+        if (sameProperties) {
+          return existingTokenAccount;
+        } else {
+          anySubAccountHaveChanged = true;
+        }
+      } else {
+        anySubAccountHaveChanged = true;
+        stats.push(`new token account ${ta.id}`);
+      }
+
+      return ta;
+    });
+
+    if (!anySubAccountHaveChanged && initialSubAccounts) {
+      // eslint-disable-next-line prettier/prettier
+      log(
+        "multiversx",
+        `incremental sync: ${String(initialSubAccounts.length)} sub accounts have not changed`,
+      );
+      subAccounts = initialSubAccounts;
+    } else {
+      log("multiversx", "incremental sync: sub accounts changed: " + stats.join(", "));
+    }
+  } else {
+    subAccounts = tokenAccounts.map((a: TokenAccount) => a);
+  }
+
+  return subAccounts;
+}

package/src/serialization.ts

@@ -0,0 +1,72 @@
+import BigNumber from "bignumber.js";
+import {
+  type MultiversXResourcesRaw,
+  type MultiversXResources,
+  type MultiversXAccountRaw,
+  type MultiversXAccount,
+  type MultiversXOperationExtraRaw,
+  type MultiversXOperationExtra,
+  isMultiversXOperationExtraRaw,
+  isMultiversXOperationExtra,
+} from "./types";
+import type { Account, AccountRaw, OperationExtra, OperationExtraRaw } from "@ledgerhq/types-live";
+
+export function toMultiversXResourcesRaw(r: MultiversXResources): MultiversXResourcesRaw {
+  const { nonce, delegations, isGuarded } = r;
+  return {
+    nonce,
+    delegations,
+    isGuarded,
+  };
+}
+
+export function fromMultiversXResourcesRaw(r: MultiversXResourcesRaw): MultiversXResources {
+  const { nonce, delegations, isGuarded } = r;
+  return {
+    nonce,
+    delegations,
+    isGuarded,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const multiversxAccount = account as MultiversXAccount;
+  if (multiversxAccount.multiversxResources) {
+    (accountRaw as MultiversXAccountRaw).multiversxResources = toMultiversXResourcesRaw(
+      multiversxAccount.multiversxResources,
+    );
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const multiversxResourcesRaw = (accountRaw as MultiversXAccountRaw).multiversxResources;
+  if (multiversxResourcesRaw)
+    (account as MultiversXAccount).multiversxResources =
+      fromMultiversXResourcesRaw(multiversxResourcesRaw);
+}
+
+export function fromOperationExtraRaw(extraRaw: OperationExtraRaw) {
+  const extra: MultiversXOperationExtra = {};
+  if (!isMultiversXOperationExtraRaw(extraRaw)) {
+    // All fields might be undefined
+    return extra;
+  }
+
+  if (extraRaw.amount) {
+    extra.amount = new BigNumber(extraRaw.amount);
+  }
+  return extra;
+}
+
+export function toOperationExtraRaw(extra: OperationExtra) {
+  const extraRaw: MultiversXOperationExtraRaw = {};
+  if (!isMultiversXOperationExtra(extra)) {
+    // All fields might be undefined
+    return extraRaw;
+  }
+
+  if (extra.amount) {
+    extraRaw.amount = extra.amount.toString();
+  }
+  return extraRaw;
+}

package/src/signOperation.ts

@@ -0,0 +1,99 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { buildTransactionToSign } from "./buildTransaction";
+import type { MultiversXAccount, Transaction } from "./types";
+import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account";
+import { extractTokenId } from "./logic";
+import { CHAIN_ID } from "./constants";
+import { MultiversXSigner } from "./signer";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<MultiversXSigner>,
+  ): AccountBridge<Transaction, MultiversXAccount>["signOperation"] =>
+  ({ account, transaction, deviceId }) =>
+    new Observable(o => {
+      let cancelled = false;
+
+      async function main() {
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        // Collect data for an ESDT transfer
+        const { subAccounts } = account;
+        const { subAccountId } = transaction;
+        const tokenAccount = !subAccountId
+          ? null
+          : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+
+        await signerContext(deviceId, signer => signer.setAddress(account.freshAddressPath));
+
+        if (tokenAccount) {
+          const { token } = decodeTokenAccountId(tokenAccount.id);
+          if (token == null) {
+            throw new Error("Invalid token");
+          }
+
+          await signerContext(deviceId, signer =>
+            signer.provideESDTInfo(
+              token.ticker,
+              extractTokenId(token.id),
+              token.units[0].magnitude,
+              CHAIN_ID,
+              token.ledgerSignature,
+            ),
+          );
+        }
+
+        const unsignedTx: string = await buildTransactionToSign(account, transaction);
+
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        const { signature } = await signerContext(deviceId, signer =>
+          signer.sign(account.freshAddressPath, unsignedTx),
+        );
+
+        if (cancelled) return;
+
+        o.next({
+          type: "device-signature-granted",
+        });
+
+        if (!signature) {
+          throw new Error("No signature");
+        }
+
+        const parsedUnsignedTx = JSON.parse(unsignedTx);
+
+        const operation = buildOptimisticOperation(account, transaction, parsedUnsignedTx);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signature.toString("hex"),
+            rawData: parsedUnsignedTx,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export default buildSignOperation;

package/src/signer.ts

@@ -0,0 +1,21 @@
+export type MultiversXAddress = {
+  publicKey: string;
+  address: string;
+};
+
+export type MultiversXSignature = {
+  signature: null | Buffer;
+};
+
+export interface MultiversXSigner {
+  getAddress(path: string, boolDisplay?: boolean): Promise<MultiversXAddress>;
+  setAddress(path: string, boolDisplay?: boolean): Promise<void>;
+  sign(path: string, message: string): Promise<MultiversXSignature>;
+  provideESDTInfo(
+    ticker?: string,
+    id?: string,
+    decimals?: number,
+    chainId?: string,
+    signature?: string,
+  ): Promise<any>;
+}