@ledgerhq/coin-multiversx 0.2.0-next.0

package/src/bridge/js.ts

@@ -0,0 +1,77 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/lib/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { broadcast } from "../broadcast";
+import { createTransaction } from "../createTransaction";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import resolver from "../hw-getAddress";
+import { getPreloadStrategy, hydrate, preload } from "../preload";
+import { prepareTransaction } from "../prepareTransaction";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+} from "../serialization";
+import { MultiversXSigner } from "../signer";
+import { buildSignOperation } from "../signOperation";
+import { getAccountShape, sync } from "../synchronisation";
+import type { MultiversXAccount, Transaction, TransactionStatus } from "../types";
+
+export function buildCurrencyBridge(
+  signerContext: SignerContext<MultiversXSigner>,
+): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    getPreloadStrategy,
+    preload,
+    hydrate,
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<MultiversXSigner>,
+): AccountBridge<Transaction, MultiversXAccount, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    fromOperationExtraRaw,
+    toOperationExtraRaw,
+    getSerializedAddressParameters,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<MultiversXSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge.integration.test.ts

@@ -0,0 +1,147 @@
+import { InvalidAddressBecauseDestinationIsAlsoSource, NotEnoughBalance } from "@ledgerhq/errors";
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+
+import { fromTransactionRaw } from "./transaction";
+import type { Transaction } from "./types";
+
+const TEST_ADDRESS = "erd1vgfp3g7azqjx4wsmtt7067m0l62v3psmqzr24j6xvywj2tlz0gesvyzsq2";
+
+const elrond: CurrenciesData<Transaction> = {
+  FIXME_ignorePreloadFields: [
+    "validators", // They are always changing
+  ],
+  scanAccounts: [
+    {
+      name: "multiversx seed 1",
+      apdus: `
+    => ed030000080000000080000000
+    <= 3e6572643176676670336737617a716a783477736d7474373036376d306c3632763370736d717a7232346a36787679776a32746c7a3067657376797a7371329000
+    => ed030000080000000080000000
+    <= 3e6572643176676670336737617a716a783477736d7474373036376d306c3632763370736d717a7232346a36787679776a32746c7a3067657376797a7371329000
+    => ed030000080000000080000001
+    <= 3e65726431706d33676a65326c6d643576796c6463767579366a7078676465347261706a70756a76756a6b65653661376a77327a6d6834747172653739367a9000
+    `,
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        id: `js:2:multiversx:${TEST_ADDRESS}:`,
+        seedIdentifier: `${TEST_ADDRESS}`,
+        name: "MultiversX 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: `${TEST_ADDRESS}`,
+        freshAddressPath: "44'/508'/0'/0'/0'",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "elrond",
+        lastSyncDate: "",
+        balance: "299569965",
+        subAccounts: [
+          {
+            // MEX account
+            id: `js:2:multiversx:${TEST_ADDRESS}:+4d45582d343535633537`,
+            balance: "100",
+            spendableBalance: "100",
+            type: "TokenAccountRaw",
+            tokenId: "multiversx/esdt/4d45582d343535633537",
+            parentId: `js:2:multiversx:${TEST_ADDRESS}:`,
+            operations: [],
+            pendingOperations: [],
+          },
+        ],
+      },
+      transactions: [
+        {
+          name: "recipient and sender must not be the same",
+          transaction: fromTransactionRaw({
+            family: "multiversx",
+            recipient: `${TEST_ADDRESS}`,
+            amount: "100000000",
+            mode: "send",
+            fees: null,
+            gasLimit: 50000000,
+          }),
+          expectedStatus: {
+            amount: new BigNumber("100000000"),
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "multiversx",
+            recipient: "erd1frj909pfums4m8aza596595l9pl56crwdj077vs2aqcw6ynl28wsfkw9rd",
+            amount: "1000000000000000000000000",
+            mode: "send",
+            fees: null,
+            gasLimit: 50000000,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance (ESDT transfer)",
+          transaction: fromTransactionRaw({
+            family: "multiversx",
+            recipient: "erd1frj909pfums4m8aza596595l9pl56crwdj077vs2aqcw6ynl28wsfkw9rd",
+            amount: "1000000000000000000000000",
+            mode: "send",
+            fees: null,
+            gasLimit: 50000000,
+            subAccountId: `js:2:multiversx:${TEST_ADDRESS}:+4d45582d343535633537`,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Send max",
+          transaction: fromTransactionRaw({
+            family: "multiversx",
+            recipient: "erd1frj909pfums4m8aza596595l9pl56crwdj077vs2aqcw6ynl28wsfkw9rd",
+            useAllAmount: true,
+            amount: "0",
+            mode: "send",
+            fees: null,
+            gasLimit: 50000000,
+          }),
+          expectedStatus: (account, _, status) => {
+            return {
+              amount: account.balance.minus(status.estimatedFees),
+              warnings: {},
+              errors: {},
+            };
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    // multiversx,
+    elrond,
+  },
+};
+
+describe("MultiversX bridge", () => {
+  test.todo(
+    "This is an empty test to make jest command pass. Remove it once there is a real test.",
+  );
+});

package/src/broadcast.ts

@@ -0,0 +1,16 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcastTransaction } from "./api";
+import { Transaction } from "./types";
+
+/**
+ * Broadcast the signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
+  const hash = await broadcastTransaction(signedOperation);
+
+  return patchOperationWithHash(signedOperation.operation, hash);
+};
+
+export default broadcast;

package/src/buildOptimisticOperation.test.ts

@@ -0,0 +1,88 @@
+import BigNumber from "bignumber.js";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { MultiversXAccount, MultiversXProtocolTransaction, Transaction } from "./types";
+
+describe("buildOptimisticOperation", () => {
+  it("should work with mode = send", async () => {
+    const account = {
+      freshAddress: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+    } as MultiversXAccount;
+
+    const transaction = {
+      family: "multiversx",
+      mode: "send",
+      fees: new BigNumber("1"),
+      amount: new BigNumber("42"),
+      recipient: "erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx",
+    } as Transaction;
+
+    const notSignedTransaction: MultiversXProtocolTransaction = {
+      nonce: 7,
+    } as MultiversXProtocolTransaction;
+
+    const operation = buildOptimisticOperation(account, transaction, notSignedTransaction);
+
+    expect(operation.type).toEqual("OUT");
+    expect(operation.value).toEqual(new BigNumber("43"));
+    expect(operation.fee).toEqual(new BigNumber("1"));
+    expect(operation.extra).toEqual({
+      amount: new BigNumber("0"),
+    });
+  });
+
+  it("should work with mode = delegate", async () => {
+    const account = {
+      freshAddress: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+    } as MultiversXAccount;
+
+    const transaction = {
+      family: "multiversx",
+      mode: "delegate",
+      fees: new BigNumber("1"),
+      amount: new BigNumber("42"),
+      recipient: "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqppllllls9ftvxy",
+      data: "delegate",
+    } as Transaction;
+
+    const notSignedTransaction: MultiversXProtocolTransaction = {
+      nonce: 7,
+    } as MultiversXProtocolTransaction;
+
+    const operation = buildOptimisticOperation(account, transaction, notSignedTransaction);
+
+    expect(operation.type).toEqual("DELEGATE");
+    expect(operation.value).toEqual(new BigNumber("43"));
+    expect(operation.fee).toEqual(new BigNumber("1"));
+    expect(operation.extra).toEqual({
+      amount: new BigNumber("42"),
+    });
+  });
+
+  it("should work with mode = claimRewards", async () => {
+    const account = {
+      freshAddress: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+    } as MultiversXAccount;
+
+    const transaction = {
+      family: "multiversx",
+      mode: "claimRewards",
+      fees: new BigNumber("1"),
+      amount: new BigNumber("42"),
+      recipient: "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqppllllls9ftvxy",
+      data: "claimRewards",
+    } as Transaction;
+
+    const notSignedTransaction: MultiversXProtocolTransaction = {
+      nonce: 7,
+    } as MultiversXProtocolTransaction;
+
+    const operation = buildOptimisticOperation(account, transaction, notSignedTransaction);
+
+    expect(operation.type).toEqual("REWARD");
+    expect(operation.value).toEqual(new BigNumber("1"));
+    expect(operation.fee).toEqual(new BigNumber("1"));
+    expect(operation.extra).toEqual({
+      amount: new BigNumber("0"),
+    });
+  });
+});

package/src/buildOptimisticOperation.ts

@@ -0,0 +1,120 @@
+import BigNumber from "bignumber.js";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { Address } from "@multiversx/sdk-core";
+import { Operation, OperationType } from "@ledgerhq/types-live";
+import { BinaryUtils } from "./utils/binary.utils";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import {
+  MultiversXAccount,
+  MultiversXProtocolTransaction,
+  MultiversXTransactionMode,
+  Transaction,
+} from "./types";
+
+function getOptimisticOperationType(transactionMode: MultiversXTransactionMode): OperationType {
+  switch (transactionMode) {
+    case "delegate":
+      return "DELEGATE";
+    case "unDelegate":
+      return "UNDELEGATE";
+    case "withdraw":
+      return "WITHDRAW_UNBONDED";
+    case "claimRewards":
+      return "REWARD";
+    case "reDelegateRewards":
+      return "DELEGATE";
+    default:
+      return "OUT";
+  }
+}
+
+function getOptimisticOperationDelegationAmount(transaction: Transaction): BigNumber | undefined {
+  let dataDecoded;
+  switch (transaction.mode) {
+    case "delegate":
+      return transaction.amount;
+
+    case "unDelegate":
+      dataDecoded = BinaryUtils.base64Decode(transaction.data ?? "");
+      return new BigNumber(`0x${dataDecoded.split("@")[1]}`);
+
+    default:
+      return new BigNumber(0);
+  }
+}
+
+export const buildOptimisticOperation = (
+  account: MultiversXAccount,
+  transaction: Transaction,
+  unsignedTx: MultiversXProtocolTransaction,
+): Operation => {
+  const senders = [account.freshAddress];
+  const recipients = [transaction.recipient];
+  const { subAccountId, fees } = transaction;
+
+  if (!fees) {
+    throw new FeeNotLoaded();
+  }
+
+  const type = getOptimisticOperationType(transaction.mode);
+
+  const tokenAccount =
+    (subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === subAccountId)) ||
+    null;
+
+  const value =
+    tokenAccount || (transaction.mode !== "send" && transaction.mode != "delegate")
+      ? fees
+      : transaction.amount.plus(transaction.fees || new BigNumber(0));
+
+  const delegationAmount = getOptimisticOperationDelegationAmount(transaction);
+
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee: fees,
+    blockHash: null,
+    blockHeight: null,
+    senders,
+    recipients,
+    accountId: account.id,
+    transactionSequenceNumber: unsignedTx.nonce,
+    date: new Date(),
+    extra: {
+      amount: delegationAmount,
+    },
+  };
+
+  const contract = new Address(transaction.recipient).isContractAddress()
+    ? transaction.recipient
+    : undefined;
+
+  if (contract) {
+    operation.contract = contract;
+  }
+
+  if (tokenAccount && subAccountId) {
+    operation.subOperations = [
+      {
+        id: encodeOperationId(subAccountId, "", "OUT"),
+        hash: "",
+        type: "OUT",
+        value: transaction.amount,
+        fee: new BigNumber(0),
+        blockHash: null,
+        blockHeight: null,
+        senders,
+        recipients,
+        accountId: subAccountId,
+        date: new Date(),
+        extra: {},
+      },
+    ];
+  }
+
+  return operation;
+};

package/src/buildSubAccounts.ts

@@ -0,0 +1,153 @@
+import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getESDTOperations, getAccountESDTTokens } from "./api";
+import { addPrefixToken, extractTokenId } from "./logic";
+
+async function buildMultiversXESDTTokenAccount({
+  parentAccountId,
+  accountAddress,
+  token,
+  balance,
+}: {
+  parentAccountId: string;
+  accountAddress: string;
+  token: TokenCurrency;
+  balance: BigNumber;
+}) {
+  const tokenAccountId = encodeTokenAccountId(parentAccountId, token);
+  const tokenIdentifierHex = extractTokenId(token.id);
+  const tokenIdentifier = Buffer.from(tokenIdentifierHex, "hex").toString();
+
+  const operations = await getESDTOperations(tokenAccountId, accountAddress, tokenIdentifier, 0);
+
+  const tokenAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId: parentAccountId,
+    token,
+    operationsCount: operations.length,
+    operations,
+    pendingOperations: [],
+    balance,
+    spendableBalance: balance,
+    swapHistory: [],
+    creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+    balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+  };
+  return tokenAccount;
+}
+
+async function syncESDTTokenAccountOperations(
+  tokenAccount: TokenAccount,
+  address: string,
+): Promise<TokenAccount> {
+  const oldOperations = tokenAccount?.operations || [];
+  // Needed for incremental synchronisation
+  const startAt = oldOperations.length ? Math.floor(oldOperations[0].date.valueOf() / 1000) : 0;
+
+  const tokenIdentifierHex = extractTokenId(tokenAccount.token.id);
+  const tokenIdentifier = Buffer.from(tokenIdentifierHex, "hex").toString();
+
+  // Merge new operations with the previously synced ones
+  const newOperations = await getESDTOperations(tokenAccount.id, address, tokenIdentifier, startAt);
+  const operations = mergeOps(oldOperations, newOperations);
+
+  if (operations === oldOperations) return tokenAccount;
+
+  const copy = { ...tokenAccount };
+  copy.operations = operations;
+  copy.operationsCount = operations.length;
+  return copy;
+}
+
+async function MultiversXBuildESDTTokenAccounts({
+  currency,
+  accountId,
+  accountAddress,
+  existingAccount,
+  syncConfig,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  accountAddress: string;
+  existingAccount: Account | null | undefined;
+  syncConfig: SyncConfig;
+}): Promise<TokenAccount[] | undefined> {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  if (listTokensForCryptoCurrency(currency).length === 0) {
+    return undefined;
+  }
+
+  const tokenAccounts: TokenAccount[] = [];
+
+  const existingAccountByTicker: { [key: string]: TokenAccount } = {}; // used for fast lookup
+
+  const existingAccountTickers: string[] = []; // used to keep track of ordering
+
+  if (existingAccount && existingAccount.subAccounts) {
+    for (const existingSubAccount of existingAccount.subAccounts) {
+      if (existingSubAccount.type === "TokenAccount") {
+        const { ticker, id } = existingSubAccount.token;
+
+        if (!blacklistedTokenIds.includes(id)) {
+          existingAccountTickers.push(ticker);
+          existingAccountByTicker[ticker] = existingSubAccount;
+        }
+      }
+    }
+  }
+
+  const accountESDTs = await getAccountESDTTokens(accountAddress);
+  for (const esdt of accountESDTs) {
+    const esdtIdentifierHex = Buffer.from(esdt.identifier).toString("hex");
+    const token = findTokenById(addPrefixToken(esdtIdentifierHex));
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      let tokenAccount = existingAccountByTicker[token.ticker];
+      if (!tokenAccount) {
+        tokenAccount = await buildMultiversXESDTTokenAccount({
+          parentAccountId: accountId,
+          accountAddress,
+          token,
+          balance: new BigNumber(esdt.balance),
+        });
+      } else {
+        const inputTokenAccount = tokenAccount;
+        tokenAccount = await syncESDTTokenAccountOperations(inputTokenAccount, accountAddress);
+        const balance = new BigNumber(esdt.balance);
+        if (!balance.eq(tokenAccount.balance)) {
+          // only recreate the object if balance changed
+          if (inputTokenAccount === tokenAccount) {
+            tokenAccount = { ...tokenAccount };
+          }
+          tokenAccount.balance = balance;
+          tokenAccount.spendableBalance = balance;
+        }
+      }
+
+      if (tokenAccount) {
+        tokenAccounts.push(tokenAccount);
+        existingAccountTickers.push(token.ticker);
+        existingAccountByTicker[token.ticker] = tokenAccount;
+      }
+    }
+  }
+
+  // Preserve order of tokenAccounts from the existing token accounts
+  tokenAccounts.sort((a, b) => {
+    const i = existingAccountTickers.indexOf(a.token.ticker);
+    const j = existingAccountTickers.indexOf(b.token.ticker);
+    if (i === j) return 0;
+    if (i < 0) return 1;
+    if (j < 0) return -1;
+    return i - j;
+  });
+
+  return tokenAccounts;
+}
+
+export default MultiversXBuildESDTTokenAccounts;

package/src/buildTransaction.ts

@@ -0,0 +1,67 @@
+import { IGasLimit, INetworkConfig, INonce } from "@multiversx/sdk-core";
+import { Account } from "@ledgerhq/types-live";
+import { getAccountNonce, getNetworkConfig } from "./api";
+import {
+  GAS_PRICE,
+  TRANSACTION_OPTIONS_TX_HASH_SIGN,
+  TRANSACTION_VERSION_DEFAULT,
+} from "./constants";
+import { isAmountSpentFromBalance } from "./logic";
+import type { MultiversXProtocolTransaction, Transaction } from "./types";
+
+/**
+ *
+ * @param {MultiversXAccount} account
+ * @param {SubAccount | null | undefined} tokenAccount
+ * @param {Transaction} transaction
+ */
+export const buildTransactionToSign = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<string> => {
+  const sender = account.freshAddress;
+  const nonce = await getAccountNonce(sender);
+  const networkConfig: INetworkConfig = await getNetworkConfig();
+  const chainID = networkConfig.ChainID.valueOf();
+
+  const isTokenAccount = account.subAccounts?.some(ta => ta.id === transaction.subAccountId);
+  const value =
+    !isTokenAccount && isAmountSpentFromBalance(transaction.mode)
+      ? transaction.amount.toFixed()
+      : "0";
+
+  return doBuildTransactionToSign({
+    transaction,
+    sender: sender,
+    nonce,
+    value,
+    minGasLimit: networkConfig.MinGasLimit,
+    chainID,
+  });
+};
+
+export const doBuildTransactionToSign = async (options: {
+  transaction: Transaction;
+  sender: string;
+  nonce: INonce;
+  value: string;
+  minGasLimit: IGasLimit;
+  chainID: string;
+}): Promise<string> => {
+  const gasLimit = options.transaction.gasLimit || options.minGasLimit.valueOf();
+
+  const transaction: MultiversXProtocolTransaction = {
+    nonce: options.nonce.valueOf(),
+    value: options.value,
+    receiver: options.transaction.recipient,
+    sender: options.sender,
+    gasPrice: GAS_PRICE,
+    gasLimit: gasLimit,
+    ...(options.transaction.data ? { data: options.transaction.data } : {}),
+    chainID: options.chainID,
+    version: TRANSACTION_VERSION_DEFAULT,
+    options: TRANSACTION_OPTIONS_TX_HASH_SIGN,
+  };
+
+  return JSON.stringify(transaction);
+};