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

package/src/bridge/signOperation.ts

@@ -1,100 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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;
-}