@ledgerhq/coin-xrp 6.2.0-next.0 → 6.2.0-next.1

package/src/{logic → bridge}/getTransactionStatus.ts

@@ -9,37 +9,40 @@ import {
   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 { getServerInfos } from "../network";
-import { cachedRecipientIsNew, parseAPIValue } from ".";
-import { Transaction, TransactionValidation, Account } from "@ledgerhq/coin-framework/api/types";
+import { cachedRecipientIsNew, parseAPIValue } from "../logic";
+import { Transaction, TransactionStatus } from "../types";
 
-export const getTransactionStatus = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<TransactionValidation> => {
+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 = transaction.fee || 0n;
-  const totalSpent = transaction.amount + estimatedFees;
-  const amount = transaction.amount;
+  const estimatedFees = new BigNumber(transaction.fee || 0);
+  const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
+  const amount = new BigNumber(transaction.amount);
 
-  if (amount > 0 && estimatedFees * 10n > 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 == 0n) {
+  } else if (transaction.fee.eq(0)) {
     errors.fee = new FeeRequired();
-  } else if (totalSpent > account.balance - BigInt(reserveBaseXRP.toString())) {
+  } else if (totalSpent.gt(account.balance.minus(reserveBaseXRP))) {
     errors.amount = new NotEnoughSpendableBalance("", {
-      minimumAmount: formatCurrencyUnit(account.currencyUnit, reserveBaseXRP, {
+      minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveBaseXRP, {
         disableRounding: true,
         useGrouping: false,
         showCode: true,
@@ -48,10 +51,10 @@ export const getTransactionStatus = async (
   } else if (
     transaction.recipient &&
     (await cachedRecipientIsNew(transaction.recipient)) &&
-    transaction.amount < BigInt(reserveBaseXRP.toString())
+    transaction.amount.lt(reserveBaseXRP)
   ) {
     errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
-      minimalAmount: formatCurrencyUnit(account.currencyUnit, reserveBaseXRP, {
+      minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveBaseXRP, {
         disableRounding: true,
         useGrouping: false,
         showCode: true,
@@ -61,15 +64,15 @@ export const getTransactionStatus = async (
 
   if (!transaction.recipient) {
     errors.recipient = new RecipientRequired("");
-  } else if (account.address === transaction.recipient) {
+  } else if (account.freshAddress === transaction.recipient) {
     errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
   } else if (!isValidClassicAddress(transaction.recipient)) {
     errors.recipient = new InvalidAddress("", {
-      currencyName: account.currencyName,
+      currencyName: account.currency.name,
     });
   }
 
-  if (!errors.amount && amount == 0n) {
+  if (!errors.amount && amount.eq(0)) {
     errors.amount = new AmountRequired();
   }
 

package/src/bridge/index.ts

@@ -0,0 +1,59 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import xrpCoinConfig, { type XrpCoinConfig } from "../config";
+import resolver from "../signer";
+import { XrpSigner } from "../types";
+import type { Transaction } from "../types";
+import { broadcast } from "./broadcast";
+import { createTransaction } from "./createTransaction";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape } from "./synchronization";
+
+export function createBridges(
+  signerContext: SignerContext<XrpSigner>,
+  coinConfig: CoinConfig<XrpCoinConfig>,
+) {
+  xrpCoinConfig.setCoinConfig(coinConfig);
+
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({ getAccountShape, getAddressFn: getAddress });
+  const currencyBridge: CurrencyBridge = {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+  const sync = makeSync({ getAccountShape });
+  const accountBridge: AccountBridge<Transaction> = {
+    createTransaction,
+    updateTransaction: updateTransaction<Transaction>,
+    prepareTransaction,
+    getTransactionStatus,
+    estimateMaxSpendable,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    getSerializedAddressParameters,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,18 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { estimateFees } from "../logic";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  _account,
+  transaction,
+) => {
+  const { networkInfo } = await estimateFees(transaction.networkInfo);
+
+  const fee = transaction.fee || networkInfo.serverFee;
+
+  if (transaction.networkInfo !== networkInfo || transaction.fee !== fee) {
+    return { ...transaction, networkInfo, fee };
+  }
+
+  return transaction;
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,100 @@
+import { Observable } from "rxjs";
+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 { craftTransaction, getNextValidSequence, removeCachedRecipientIsNew } from "../logic";
+import { Transaction, XrpSignature, XrpSigner } from "../types";
+
+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 {
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const nextSequenceNumber = await getNextValidSequence(account.freshAddress);
+
+          const signature = await signerContext(deviceId, async signer => {
+            const { freshAddressPath: derivationPath } = account;
+            const { publicKey } = await signer.getAddress(derivationPath);
+
+            const { xrplTransaction, serializedTransaction } = await craftTransaction(
+              {
+                address: account.freshAddress,
+                nextSequenceNumber,
+              },
+              {
+                recipient: transaction.recipient,
+                amount: BigInt(transaction.amount.toString()),
+                fee: BigInt(fee.toString()),
+                destinationTag: transaction.tag,
+              },
+              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/bridge/synchronization.test.ts

@@ -0,0 +1,153 @@
+import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { Account, SyncConfig } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { getAccountShape } from "./synchronization";
+
+const mockGetServerInfos = jest.fn().mockResolvedValue({
+  info: {
+    complete_ledgers: "1-2",
+    validated_ledger: {
+      reserve_base_xrp: "0",
+      reserve_inc_xrp: "0",
+    },
+  },
+});
+const mockGetAccountInfo = jest.fn().mockResolvedValue({
+  isNewAccount: true,
+  balance: "0",
+  ownerCount: 0,
+  sequence: 0,
+});
+const mockGetTransactions = jest.fn();
+jest.mock("../network", () => ({
+  getServerInfos: () => mockGetServerInfos(),
+  getAccountInfo: () => mockGetAccountInfo(),
+  getTransactions: () => mockGetTransactions(),
+}));
+
+describe("getAccountShape", () => {
+  beforeEach(() => {
+    mockGetServerInfos.mockClear();
+    mockGetAccountInfo.mockClear();
+    mockGetTransactions.mockClear();
+  });
+
+  it("returns early when account is new", async () => {
+    // Given
+    mockGetAccountInfo.mockResolvedValue({
+      isNewAccount: true,
+      balance: "0",
+      ownerCount: 0,
+      sequence: 0,
+    });
+
+    // When
+    const account = await getAccountShape(
+      {
+        address: "address",
+        currency: getCryptoCurrencyById("ripple"),
+        derivationMode: "",
+        index: 0,
+      } as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    // Then
+    expect(mockGetAccountInfo).toHaveBeenCalledTimes(1);
+    expect(mockGetServerInfos).toHaveBeenCalledTimes(0);
+    expect(mockGetTransactions).toHaveBeenCalledTimes(0);
+    expect(account).toEqual({
+      id: "js:2:ripple:address:",
+      xpub: "address",
+      blockHeight: 0,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operations: [],
+      operationsCount: 0,
+    });
+  });
+
+  const someMarker = { ledger: 1, seq: 1 };
+  function mockNetworkTxs(txs: unknown): unknown {
+    return {
+      account: "account",
+      ledger_index_max: 1,
+      ledger_index_min: 1,
+      limit: 1,
+      validated: false,
+      transactions: txs,
+      marker: someMarker,
+      error: "",
+    };
+  }
+
+  it("convert correctly operations", async () => {
+    // Given
+    mockGetAccountInfo.mockResolvedValue({
+      isNewAccount: false,
+      balance: "0",
+      ownerCount: 0,
+      sequence: 0,
+    });
+    mockGetTransactions.mockResolvedValue(
+      mockNetworkTxs([
+        {
+          ledger_hash: "HASH_VALUE_BLOCK",
+          hash: "HASH_VALUE",
+          meta: { delivered_amount: "100" },
+          tx_json: {
+            TransactionType: "Payment",
+            Fee: "10",
+            ledger_index: 1,
+            date: 1000,
+            Account: "account_addr",
+            Destination: "destination_addr",
+            Sequence: 1,
+          },
+        },
+      ]),
+    );
+
+    // When
+    const account = await getAccountShape(
+      {
+        address: "address",
+        currency: getCryptoCurrencyById("ripple"),
+        derivationMode: "",
+        index: 0,
+      } as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    // Then
+    expect(mockGetAccountInfo).toHaveBeenCalledTimes(1);
+    expect(mockGetServerInfos).toHaveBeenCalled();
+    expect(mockGetTransactions).toHaveBeenCalledTimes(1);
+    expect(account).toEqual({
+      id: "js:2:ripple:address:",
+      xpub: "address",
+      blockHeight: 2,
+      operationsCount: 1,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operations: [
+        {
+          accountId: "js:2:ripple:address:",
+          blockHash: "HASH_VALUE_BLOCK",
+          blockHeight: 1,
+          date: new Date("2000-01-01T00:16:40.000Z"),
+          hash: "HASH_VALUE",
+          id: "js:2:ripple:address:-HASH_VALUE-IN",
+          recipients: ["destination_addr"],
+          senders: ["account_addr"],
+          transactionSequenceNumber: 1,
+          type: "IN",
+          value: new BigNumber("100"),
+          fee: new BigNumber("10"),
+          extra: {},
+        },
+      ],
+    });
+  });
+});

package/src/bridge/synchronization.ts

@@ -0,0 +1,108 @@
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Operation, OperationType } from "@ledgerhq/types-live";
+import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
+import BigNumber from "bignumber.js";
+import { listOperations, parseAPIValue } from "../logic";
+import { getAccountInfo, getServerInfos } from "../network";
+import { ServerInfoResponse } from "../network/types";
+import { AccountInfo, XrpAsset } from "../types";
+
+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.isNewAccount) {
+    return {
+      id: accountId,
+      xpub: address,
+      blockHeight: 0,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operations: [],
+      operationsCount: 0,
+    };
+  }
+
+  const oldOperations = initialAccount?.operations || [];
+  const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+
+  const serverInfo = await getServerInfos();
+  const ledgers = serverInfo.info.complete_ledgers.split("-");
+  const maxLedgerVersion = Number(ledgers[1]);
+
+  const balance = new BigNumber(accountInfo.balance);
+  const spendableBalance = await calculateSpendableBalance(accountInfo, serverInfo);
+
+  const newOperations = await filterOperations(accountId, address, blockHeight);
+
+  const operations = mergeOps(oldOperations, newOperations);
+
+  const shape = {
+    id: accountId,
+    xpub: address,
+    blockHeight: maxLedgerVersion,
+    balance,
+    spendableBalance,
+    operations,
+    operationsCount: operations.length,
+  };
+
+  return shape;
+};
+
+async function filterOperations(
+  accountId: string,
+  address: string,
+  blockHeight: number,
+): Promise<Operation[]> {
+  const [operations, _] = await listOperations(address, { minHeight: blockHeight });
+
+  return operations.map(op => adaptCoreOperationToLiveOperation(accountId, op) satisfies Operation);
+}
+
+function adaptCoreOperationToLiveOperation(
+  accountId: string,
+  op: CoreOperation<XrpAsset>,
+): Operation {
+  return {
+    id: encodeOperationId(accountId, op.tx.hash, op.type),
+    hash: op.tx.hash,
+    accountId,
+    type: op.type as OperationType,
+    value: new BigNumber(op.value.toString()),
+    fee: new BigNumber(op.tx.fees.toString()),
+    blockHash: op.tx.block.hash,
+    blockHeight: op.tx.block.height,
+    senders: op.senders,
+    recipients: op.recipients,
+    date: op.tx.date,
+    transactionSequenceNumber: op.details?.sequence as number,
+    extra: {},
+  };
+}
+
+async function calculateSpendableBalance(
+  account: AccountInfo,
+  serverInfo: ServerInfoResponse,
+): Promise<BigNumber> {
+  const reserveMinXRP = parseAPIValue(serverInfo.info.validated_ledger.reserve_base_xrp.toString());
+  const reservePerTrustline = parseAPIValue(
+    serverInfo.info.validated_ledger.reserve_inc_xrp.toString(),
+  );
+  const trustlines = account.ownerCount;
+
+  const spendableBalance = new BigNumber(account.balance)
+    .minus(reserveMinXRP)
+    .minus(reservePerTrustline.times(trustlines));
+
+  return spendableBalance;
+}

package/src/{transaction.ts → bridge/transaction.ts}

@@ -1,5 +1,5 @@
 import { BigNumber } from "bignumber.js";
-import type { Transaction, TransactionRaw } from "./types";
+import type { Transaction, TransactionRaw } from "../types";
 import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
 import {
   fromTransactionCommonRaw,

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 
+export { createBridges } from "./bridge/index";
 export type { XrpCoinConfig } from "./config";

package/src/logic/combine.ts

@@ -8,18 +8,11 @@ type XRPTransaction = JsonObject & {
 
 export function combine(transaction: string, signature: string, publicKey?: string): string {
   const xrplTransaction: JsonObject = decode(transaction);
-
-  let transactionWithSignature: XRPTransaction = { ...xrplTransaction } as any;
+  let transactionWithSignature: XRPTransaction = { ...xrplTransaction, TxnSignature: signature };
 
   if (publicKey) {
-    transactionWithSignature = {
-      ...transactionWithSignature,
-      SigningPubKey: publicKey,
-    };
+    transactionWithSignature = { ...transactionWithSignature, SigningPubKey: publicKey };
   }
 
-  transactionWithSignature = { ...transactionWithSignature, TxnSignature: signature };
-
-  const encoded = encode(transactionWithSignature).toUpperCase();
-  return encoded;
+  return encode(transactionWithSignature);
 }

package/src/logic/getBalance.test.ts

@@ -2,33 +2,21 @@ import { faker } from "@faker-js/faker";
 import { getBalance } from "./getBalance";
 
 const mockGetAccountInfo = jest.fn();
-const mockGetServerInfos = jest.fn();
 jest.mock("../network", () => ({
   getAccountInfo: (address: string) => mockGetAccountInfo(address),
-  getServerInfos: () => mockGetServerInfos(),
 }));
 
 describe("getBalance", () => {
   afterEach(() => {
     mockGetAccountInfo.mockClear();
-    mockGetServerInfos.mockClear();
   });
 
   it("returns the balance from Explorer", async () => {
-    mockGetServerInfos.mockResolvedValue({
-      info: {
-        validated_ledger: {
-          reserve_base_xrp: 23,
-          reserve_inc_xrp: 5,
-        },
-      },
-    });
     // Given
     const balance = faker.number.bigInt(100_000_000);
     const address = "ACCOUNT_ADDRESS";
     mockGetAccountInfo.mockResolvedValue({
       balance,
-      ownerCount: 0,
     });
 
     // When
@@ -36,8 +24,7 @@ describe("getBalance", () => {
 
     // Then
     expect(mockGetAccountInfo).toHaveBeenCalledTimes(1);
-    expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     expect(mockGetAccountInfo.mock.lastCall[0]).toEqual(address);
-    expect(result).toEqual([{ value: balance, asset: { type: "native" }, locked: 23000000n }]);
+    expect(result).toEqual([{ value: balance, asset: { type: "native" } }]);
   });
 });

package/src/logic/getBalance.ts

@@ -1,24 +1,8 @@
 import { Balance } from "@ledgerhq/coin-framework/api/types";
-import { getAccountInfo, getServerInfos } from "../network";
+import { getAccountInfo } from "../network";
 import { XrpAsset } from "../types";
-import { parseAPIValue } from "./common";
 
 export async function getBalance(address: string): Promise<Balance<XrpAsset>[]> {
   const accountInfo = await getAccountInfo(address);
-  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 trustlines = accountInfo.ownerCount;
-
-  const locked = reserveMinXRP.plus(reservePerTrustline.times(trustlines));
-  return [
-    {
-      value: BigInt(accountInfo.balance),
-      asset: { type: "native" },
-      locked: BigInt(locked.toString()),
-    },
-  ];
+  return [{ value: BigInt(accountInfo.balance), asset: { type: "native" } }];
 }

package/src/logic/index.ts

@@ -6,7 +6,11 @@ export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";
 export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
-export { getTransactionStatus } from "./getTransactionStatus";
-export { RIPPLE_EPOCH, cachedRecipientIsNew, getNextValidSequence } from "./utils";
+export {
+  RIPPLE_EPOCH,
+  cachedRecipientIsNew,
+  getNextValidSequence,
+  removeCachedRecipientIsNew,
+} from "./utils";
 
 export { parseAPIValue } from "./common";