@ledgerhq/coin-xrp 0.2.0-next.0

package/src/getTransactionStatus.ts

@@ -0,0 +1,86 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  FeeRequired,
+  FeeTooHigh,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughSpendableBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { isValidClassicAddress } from "ripple-address-codec";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { Transaction, TransactionStatus } from "./types";
+import { getServerInfos, parseAPIValue } from "./api";
+import { cachedRecipientIsNew } from "./logic";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  Account,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const serverInfos = await getServerInfos();
+  const reserveBaseXRP = parseAPIValue(
+    serverInfos.info.validated_ledger.reserve_base_xrp.toString(),
+  );
+  const estimatedFees = new BigNumber(transaction.fee || 0);
+  const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
+  const amount = new BigNumber(transaction.amount);
+
+  if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+    warnings.feeTooHigh = new FeeTooHigh();
+  }
+
+  if (!transaction.fee) {
+    errors.fee = new FeeNotLoaded();
+  } else if (transaction.fee.eq(0)) {
+    errors.fee = new FeeRequired();
+  } else if (totalSpent.gt(account.balance.minus(reserveBaseXRP))) {
+    errors.amount = new NotEnoughSpendableBalance("", {
+      minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveBaseXRP, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  } else if (
+    transaction.recipient &&
+    (await cachedRecipientIsNew(transaction.recipient)) &&
+    transaction.amount.lt(reserveBaseXRP)
+  ) {
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveBaseXRP, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  }
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired("");
+  } else if (account.freshAddress === transaction.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isValidClassicAddress(transaction.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!errors.amount && amount.eq(0)) {
+    errors.amount = new AmountRequired();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/hw-getAddress.ts

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

package/src/logic.ts

@@ -0,0 +1,101 @@
+import BigNumber from "bignumber.js";
+import { Account, Operation } from "@ledgerhq/types-live";
+import { isValidClassicAddress } from "ripple-address-codec";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { XrplOperation } from "./api/types";
+import { getAccountInfo } from "./api";
+
+export const NEW_ACCOUNT_ERROR_MESSAGE = "actNotFound";
+export const UINT32_MAX = new BigNumber(2).pow(32).minus(1);
+
+/** @see https://xrpl.org/basic-data-types.html#specifying-time */
+const RIPPLE_EPOCH = 946684800;
+
+export const validateTag = (tag: BigNumber) => {
+  return (
+    !tag.isNaN() && tag.isFinite() && tag.isInteger() && tag.isPositive() && tag.lte(UINT32_MAX)
+  );
+};
+
+export const getNextValidSequence = async (account: Account) => {
+  const accInfo = await getAccountInfo(account.freshAddress, true);
+  return accInfo.account_data.Sequence;
+};
+
+function isRecipientValid(recipient: string): boolean {
+  return isValidClassicAddress(recipient);
+}
+
+const recipientIsNew = async (recipient: string): Promise<boolean> => {
+  if (!isRecipientValid(recipient)) return false;
+
+  const info = await getAccountInfo(recipient);
+  if (info.error === NEW_ACCOUNT_ERROR_MESSAGE) {
+    return true;
+  }
+  return false;
+};
+
+const cacheRecipientsNew: Record<string, boolean> = {};
+export const cachedRecipientIsNew = async (recipient: string) => {
+  if (recipient in cacheRecipientsNew) return cacheRecipientsNew[recipient];
+  cacheRecipientsNew[recipient] = await recipientIsNew(recipient);
+  return cacheRecipientsNew[recipient];
+};
+export const removeCachedRecipientIsNew = (recipient: string) => {
+  delete cacheRecipientsNew[recipient];
+};
+
+const XrplOperationToLiveOperation =
+  (accountId: string, address: string) =>
+  ({
+    meta: { delivered_amount },
+    tx: { Fee, hash, inLedger, date, Account, Destination, Sequence },
+  }: XrplOperation) => {
+    const type = Account === address ? "OUT" : "IN";
+    let value =
+      delivered_amount && typeof delivered_amount === "string"
+        ? new BigNumber(delivered_amount)
+        : new BigNumber(0);
+    const feeValue = new BigNumber(Fee);
+
+    if (type === "OUT") {
+      if (!Number.isNaN(feeValue)) {
+        value = value.plus(feeValue);
+      }
+    }
+
+    const toEpochDate = (RIPPLE_EPOCH + date) * 1000;
+
+    const op: Operation = {
+      id: encodeOperationId(accountId, hash, type),
+      hash: hash,
+      accountId: accountId,
+      type,
+      value,
+      fee: feeValue,
+      blockHash: null,
+      blockHeight: inLedger,
+      senders: [Account],
+      recipients: [Destination],
+      date: new Date(toEpochDate),
+      transactionSequenceNumber: Sequence,
+      extra: {},
+    };
+
+    return op;
+  };
+
+export const filterOperations = (
+  transactions: XrplOperation[],
+  accountId: string,
+  address: string,
+) => {
+  return transactions
+    .filter(
+      ({ tx, meta }: XrplOperation) =>
+        tx.TransactionType === "Payment" && typeof meta.delivered_amount === "string",
+    )
+    .map(XrplOperationToLiveOperation(accountId, address))
+    .filter((op): op is Operation => Boolean(op));
+};

package/src/prepareTransaction.ts

@@ -0,0 +1,48 @@
+import BigNumber from "bignumber.js";
+import { NetworkDown } from "@ledgerhq/errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getServerInfos, parseAPIValue } from "./api";
+import { NetworkInfo, Transaction } from "./types";
+
+// FIXME this could be cleaner
+const remapError = (error: Error) => {
+  const msg = error.message;
+
+  if (msg.includes("Unable to resolve host") || msg.includes("Network is down")) {
+    return new NetworkDown();
+  }
+
+  return error;
+};
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  let networkInfo: NetworkInfo | null | undefined = transaction.networkInfo;
+
+  if (!networkInfo) {
+    try {
+      const info = await getServerInfos();
+      const serverFee = parseAPIValue(info.info.validated_ledger.base_fee_xrp.toString());
+      networkInfo = {
+        family: "xrp",
+        serverFee,
+        baseReserve: new BigNumber(0), // NOT USED. will refactor later.
+      };
+    } catch (e) {
+      if (e instanceof Error) {
+        throw remapError(e);
+      }
+      throw e;
+    }
+  }
+
+  const fee = transaction.fee || networkInfo.serverFee;
+
+  if (transaction.networkInfo !== networkInfo || transaction.fee !== fee) {
+    return { ...transaction, networkInfo, fee };
+  }
+
+  return transaction;
+};

package/src/signOperation.ts

@@ -0,0 +1,129 @@
+import invariant from "invariant";
+import { Observable } from "rxjs";
+import BigNumber from "bignumber.js";
+import { encode } from "ripple-binary-codec";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge, Operation } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import XrplDefinitions from "ripple-binary-codec/dist/enums/definitions.json";
+import { getNextValidSequence, removeCachedRecipientIsNew, UINT32_MAX, validateTag } from "./logic";
+import { XrpSignature, XrpSigner } from "./signer";
+import { getLedgerIndex } from "./api";
+import { Transaction } from "./types";
+
+const LEDGER_OFFSET = 20;
+
+const { TRANSACTION_TYPES } = XrplDefinitions;
+type XrplTransaction = {
+  TransactionType: keyof typeof TRANSACTION_TYPES;
+  Flags: number;
+  Account: string;
+  Amount: string;
+  Destination: string;
+  DestinationTag: number | undefined;
+  Fee: string;
+  Sequence: number;
+  LastLedgerSequence: number;
+  SigningPubKey?: string;
+  TxnSignature?: string;
+};
+
+export const buildSignOperation =
+  (signerContext: SignerContext<XrpSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({ account, deviceId, transaction }) =>
+    new Observable(o => {
+      removeCachedRecipientIsNew(transaction.recipient);
+
+      async function main() {
+        const { fee } = transaction;
+        if (!fee) throw new FeeNotLoaded();
+        try {
+          const tag = transaction.tag ? transaction.tag : undefined;
+          const nextSequenceNumber = await getNextValidSequence(account);
+          const xrplTransaction: XrplTransaction = {
+            TransactionType: "Payment",
+            Account: account.freshAddress,
+            Amount: transaction.amount.toFixed(),
+            Destination: transaction.recipient,
+            DestinationTag: tag,
+            Fee: fee.toFixed(),
+            Flags: 2147483648,
+            Sequence: nextSequenceNumber,
+            LastLedgerSequence: (await getLedgerIndex()) + LEDGER_OFFSET,
+          };
+
+          if (tag)
+            invariant(
+              validateTag(new BigNumber(tag)),
+              `tag is set but is not in a valid format, should be between [0 - ${UINT32_MAX.toString()}]`,
+            );
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const signature = (await signerContext(deviceId, async signer => {
+            const { freshAddressPath: derivationPath } = account;
+            const { publicKey } = await signer.getAddress(derivationPath);
+
+            const serializedTransaction = encode({
+              ...xrplTransaction,
+              SigningPubKey: publicKey,
+            });
+            const transactionSignature = await signer.signTransaction(
+              derivationPath,
+              serializedTransaction,
+            );
+
+            return encode({
+              ...xrplTransaction,
+              SigningPubKey: publicKey,
+              TxnSignature: transactionSignature,
+            }).toUpperCase();
+          })) as XrpSignature;
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          const hash = "";
+          const operation: Operation = {
+            id: encodeOperationId(account.id, hash, "OUT"),
+            hash,
+            accountId: account.id,
+            type: "OUT",
+            value: transaction.amount,
+            fee,
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            date: new Date(),
+            transactionSequenceNumber: nextSequenceNumber,
+            extra: {},
+          };
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature,
+            },
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            throw new Error(
+              (e as Error & { data?: { resultMessage?: string } })?.data?.resultMessage,
+            );
+          }
+
+          throw e;
+        }
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/signer.ts

@@ -0,0 +1,17 @@
+export type XrpAddress = {
+  publicKey: string;
+  address: string;
+  chainCode?: string;
+};
+
+export type XrpSignature = string; // `0x${string}`
+
+export interface XrpSigner {
+  getAddress(
+    path: string,
+    display?: boolean,
+    chainCode?: boolean,
+    ed25519?: boolean,
+  ): Promise<XrpAddress>;
+  signTransaction(path: string, rawTxHex: string, ed25519?: boolean): Promise<XrpSignature>;
+}

package/src/specs.ts

@@ -0,0 +1,73 @@
+import invariant from "invariant";
+import expect from "expect";
+import { DeviceModelId } from "@ledgerhq/devices";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import { acceptTransaction } from "./speculos-deviceActions";
+import type { Transaction } from "./types";
+
+const currency = getCryptoCurrencyById("ripple");
+const minAmountCutoff = parseCurrencyUnit(currency.units[0], "0.1");
+const reserve = parseCurrencyUnit(currency.units[0], "20");
+
+const xrp: AppSpec<Transaction> = {
+  name: "XRP",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "XRP",
+  },
+  genericDeviceAction: acceptTransaction,
+  minViableAmount: minAmountCutoff,
+  mutations: [
+    {
+      name: "move ~50%",
+      maxRun: 2,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minAmountCutoff), "balance is too low");
+        const transaction = bridge.createTransaction(account);
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        let amount = maxSpendable.div(1.9 + 0.2 * Math.random()).integerValue();
+
+        if (!sibling.used && amount.lt(reserve)) {
+          invariant(
+            maxSpendable.gt(reserve.plus(minAmountCutoff)),
+            "not enough funds to send to new account",
+          );
+          amount = reserve;
+        }
+
+        return {
+          transaction,
+          updates: [
+            {
+              amount,
+            },
+            {
+              recipient,
+            },
+            Math.random() > 0.5
+              ? {
+                  tag: 123,
+                }
+              : null,
+          ],
+        };
+      },
+      test: ({ account, accountBeforeTransaction, operation }) => {
+        botTest("account balance moved with operation.value", () =>
+          expect(account.balance.toString()).toBe(
+            accountBeforeTransaction.balance.minus(operation.value).toString(),
+          ),
+        );
+      },
+    },
+  ],
+};
+export default {
+  xrp,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,53 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Transaction Type",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "Payment",
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) => formatDeviceAmount(account.currency, status.amount),
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatDeviceAmount(account.currency, status.estimatedFees),
+    },
+    {
+      title: "Destination Tag",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => String(transaction.tag),
+    },
+    {
+      title: "Destination",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Account",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Sign transaction",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/synchronization.ts

@@ -0,0 +1,73 @@
+import BigNumber from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getAccountInfo, getServerInfos, getTransactions, parseAPIValue } from "./api";
+import { NEW_ACCOUNT_ERROR_MESSAGE, filterOperations } from "./logic";
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const accountInfo = await getAccountInfo(address);
+
+  if (!accountInfo || accountInfo.error === NEW_ACCOUNT_ERROR_MESSAGE) {
+    return {
+      id: accountId,
+      xpub: address,
+      blockHeight: 0,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operations: [],
+      operationsCount: 0,
+    };
+  }
+
+  const serverInfo = await getServerInfos();
+  const reserveMinXRP = parseAPIValue(serverInfo.info.validated_ledger.reserve_base_xrp.toString());
+  const reservePerTrustline = parseAPIValue(
+    serverInfo.info.validated_ledger.reserve_inc_xrp.toString(),
+  );
+
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+
+  const ledgers = serverInfo.info.complete_ledgers.split("-");
+  const minLedgerVersion = Number(ledgers[0]);
+  const maxLedgerVersion = Number(ledgers[1]);
+
+  const trustlines = accountInfo.account_data.OwnerCount;
+
+  const balance = new BigNumber(accountInfo.account_data.Balance);
+  const spendableBalance = new BigNumber(accountInfo.account_data.Balance)
+    .minus(reserveMinXRP)
+    .minus(reservePerTrustline.times(trustlines));
+
+  const newTransactions = await getTransactions(address, {
+    ledger_index_min: Math.max(
+      startAt, // if there is no ops, it might be after a clear and we prefer to pull from the oldest possible history
+      minLedgerVersion,
+    ),
+    ledger_index_max: maxLedgerVersion,
+  });
+  const newOperations = filterOperations(newTransactions, accountId, address);
+
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const shape = {
+    id: accountId,
+    xpub: address,
+    blockHeight: maxLedgerVersion,
+    balance,
+    spendableBalance,
+    operations,
+    operationsCount: operations.length,
+  };
+
+  return shape;
+};

package/src/transaction.ts

@@ -0,0 +1,79 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction, TransactionRaw } from "./types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization/transaction";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+export const formatTransaction = (
+  { amount, recipient, fee, tag, useAllAmount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}
+TO ${recipient}
+with fee=${
+  !fee
+    ? "?"
+    : formatCurrencyUnit(getAccountCurrency(account).units[0], fee, {
+        showCode: true,
+        disableRounding: true,
+      })
+}${tag ? "\n  tag=" + tag : ""}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  const { networkInfo } = tr;
+  return {
+    ...common,
+    family: tr.family,
+    tag: tr.tag,
+    fee: tr.fee ? new BigNumber(tr.fee) : null,
+    feeCustomUnit: tr.feeCustomUnit,
+    // FIXME remove this field. this is not good.. we're dereferencing here. we should instead store an index (to lookup in currency.units on UI)
+    networkInfo: networkInfo && {
+      family: networkInfo.family,
+      serverFee: new BigNumber(networkInfo.serverFee),
+      baseReserve: new BigNumber(networkInfo.baseReserve),
+    },
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  const { networkInfo } = t;
+  return {
+    ...common,
+    family: t.family,
+    tag: t.tag,
+    fee: t.fee ? t.fee.toString() : null,
+    feeCustomUnit: t.feeCustomUnit,
+    // FIXME remove this field. this is not good.. we're dereferencing here. we should instead store an index (to lookup in currency.units on UI)
+    networkInfo: networkInfo && {
+      family: networkInfo.family,
+      serverFee: networkInfo.serverFee.toString(),
+      baseReserve: networkInfo.baseReserve.toString(),
+    },
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};