@ledgerhq/coin-xrp 0.2.0-next.0

package/src/api/index.ts

@@ -0,0 +1,138 @@
+import { BigNumber } from "bignumber.js";
+import network from "@ledgerhq/live-network/network";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { NEW_ACCOUNT_ERROR_MESSAGE } from "../logic";
+import { getCoinConfig } from "../config";
+import {
+  AccountInfoResponse,
+  AccountTxResponse,
+  LedgerResponse,
+  ServerInfoResponse,
+  SubmitReponse,
+} from "./types";
+
+const rippleUnit = getCryptoCurrencyById("ripple").units[0];
+
+export const parseAPIValue = (value: string): BigNumber => parseCurrencyUnit(rippleUnit, value);
+
+export const submit = async (signature: string): Promise<SubmitReponse> => {
+  const {
+    data: { result },
+  } = await network<{ result: SubmitReponse }>({
+    method: "POST",
+    url: getCoinConfig().node,
+    data: {
+      method: "submit",
+      params: [
+        {
+          tx_blob: signature,
+        },
+      ],
+    },
+  });
+  return result;
+};
+
+export const getAccountInfo = async (
+  recipient: string,
+  current?: boolean,
+): Promise<AccountInfoResponse> => {
+  const {
+    data: { result },
+  } = await network<{ result: AccountInfoResponse }>({
+    method: "POST",
+    url: getCoinConfig().node,
+    data: {
+      method: "account_info",
+      params: [
+        {
+          account: recipient,
+          ledger_index: current ? "current" : "validated",
+        },
+      ],
+    },
+  });
+
+  if (result.status !== "success" && result.error !== NEW_ACCOUNT_ERROR_MESSAGE) {
+    throw new Error(`couldn't fetch account info ${recipient}`);
+  }
+
+  return result;
+};
+
+export const getServerInfos = async (
+  endpointConfig?: string | null | undefined,
+): Promise<ServerInfoResponse> => {
+  const {
+    data: { result },
+  } = await network<{ result: ServerInfoResponse }>({
+    method: "POST",
+    url: endpointConfig ?? getCoinConfig().node,
+    data: {
+      method: "server_info",
+      params: [
+        {
+          ledger_index: "validated",
+        },
+      ],
+    },
+  });
+
+  if (result.status !== "success") {
+    throw new Error(`couldn't fetch server info`);
+  }
+
+  return result;
+};
+
+export const getTransactions = async (
+  address: string,
+  options: { ledger_index_min?: number; ledger_index_max?: number } | undefined,
+): Promise<AccountTxResponse["transactions"]> => {
+  const {
+    data: { result },
+  } = await network<{ result: AccountTxResponse }>({
+    method: "POST",
+    url: getCoinConfig().node,
+    data: {
+      method: "account_tx",
+      params: [
+        {
+          account: address,
+          ledger_index: "validated",
+          ...options,
+        },
+      ],
+    },
+  });
+
+  if (result.status !== "success") {
+    throw new Error(`couldn't getTransactions for ${address}`);
+  }
+
+  return result.transactions;
+};
+
+export async function getLedgerIndex(): Promise<number> {
+  const {
+    data: { result },
+  } = await network<{ result: LedgerResponse }>({
+    method: "POST",
+    url: getCoinConfig().node,
+    data: {
+      method: "ledger",
+      params: [
+        {
+          ledger_index: "validated",
+        },
+      ],
+    },
+  });
+
+  if (result.status !== "success") {
+    throw new Error(`couldn't fetch getLedgerIndex`);
+  }
+
+  return result.ledger_index;
+}

package/src/api/types.ts

@@ -0,0 +1,191 @@
+export type XrplOperation = {
+  meta: {
+    AffectedNodes: {
+      ModifiedNode: {
+        FinalFields: {
+          Account: string;
+          Balance: string;
+          Flags: number;
+          OwnerCount: number;
+          Sequence: number;
+        };
+        LedgerEntryType: string;
+        LedgerIndex: string;
+        PreviousFields: {
+          Balance: string;
+        };
+        PreviousTxnID: string;
+        PreviousTxnLgrSeq: number;
+      };
+    }[];
+    TransactionIndex: number;
+    TransactionResult: string;
+    delivered_amount: string;
+  };
+  tx: {
+    Account: string;
+    Amount: string;
+    DeliverMax: string;
+    Destination: string;
+    DestinationTag: number;
+    Fee: string;
+    Flags: number;
+    LastLedgerSequence: number;
+    Memos: {
+      Memo: {
+        MemoData: string;
+      };
+    }[];
+    Sequence: number;
+    SigningPubKey: string;
+    TransactionType: string;
+    TxnSignature: string;
+    date: number;
+    hash: string;
+    inLedger: number;
+    ledger_index: number;
+  };
+  validated: boolean;
+};
+
+type ResponseStatus =
+  | { status: string; error?: never }
+  | {
+      status?: never;
+      error: string;
+    };
+
+export type AccountInfoResponse = {
+  account_data: {
+    Account: string;
+    Balance: string;
+    Flags: number;
+    LedgerEntryType: string;
+    OwnerCount: number;
+    PreviousTxnID: string;
+    PreviousTxnLgrSeq: number;
+    Sequence: number;
+    index: string;
+  };
+  account_flags: {
+    allowTrustLineClawback: boolean;
+    defaultRipple: boolean;
+    depositAuth: boolean;
+    disableMasterKey: boolean;
+    disallowIncomingCheck: boolean;
+    disallowIncomingNFTokenOffer: boolean;
+    disallowIncomingPayChan: boolean;
+    disallowIncomingTrustline: boolean;
+    disallowIncomingXRP: boolean;
+    globalFreeze: boolean;
+    noFreeze: boolean;
+    passwordSpent: boolean;
+    requireAuthorization: boolean;
+    requireDestinationTag: boolean;
+  };
+  ledger_hash: string;
+  ledger_index: number;
+  validated: boolean;
+} & ResponseStatus;
+
+export type SubmitReponse = {
+  accepted: boolean;
+  account_sequence_available: number;
+  account_sequence_next: number;
+  applied: boolean;
+  broadcast: boolean;
+  engine_result: string;
+  engine_result_code: 0;
+  engine_result_message: string;
+  kept: boolean;
+  open_ledger_cost: string;
+  queued: false;
+  status: string;
+  tx_blob: string;
+  tx_json: {
+    Account: string;
+    Amount: string;
+    Destination: string;
+    Fee: string;
+    Flags: number;
+    LastLedgerSequence: number;
+    Sequence: number;
+    SigningPubKey: string;
+    TransactionType: string;
+    TxnSignature: string;
+    hash: string;
+  };
+  validated_ledger_index: number;
+};
+
+export type ServerInfoResponse = {
+  info: {
+    build_version: string;
+    complete_ledgers: string;
+    hostid: string;
+    initial_sync_duration_us: string;
+    io_latency_ms: number;
+    jq_trans_overflow: string;
+    last_close: {
+      converge_time_s: number;
+      proposers: number;
+    };
+    load_factor: number;
+    network_id: number;
+    peer_disconnects: string;
+    peer_disconnects_resources: string;
+    peers: number;
+    ports: { port: string; protocol: ["ws" | "http" | "peer"] }[];
+    pubkey_node: string;
+    server_state: string;
+    server_state_duration_us: string;
+    state_accounting: Record<
+      "connected" | "disconnected" | "full" | "syncing" | "tracking",
+      {
+        duration_us: string;
+        transitions: string;
+      }
+    >;
+    time: string;
+    uptime: number;
+    validated_ledger: {
+      age: number;
+      base_fee_xrp: number;
+      hash: string;
+      reserve_base_xrp: number;
+      reserve_inc_xrp: number;
+      seq: number;
+    };
+    validation_quorum: number;
+  };
+} & ResponseStatus;
+
+export type AccountTxResponse = {
+  account: string;
+  ledger_index_max: number;
+  ledger_index_min: number;
+  limit: number;
+  transactions: XrplOperation[];
+  validated: boolean;
+} & ResponseStatus;
+
+export type LedgerResponse = {
+  ledger: {
+    account_hash: string;
+    close_flags: number;
+    close_time: number;
+    close_time_human: string;
+    close_time_iso: string;
+    close_time_resolution: number;
+    closed: boolean;
+    ledger_hash: string;
+    ledger_index: string;
+    parent_close_time: number;
+    parent_hash: string;
+    total_coins: string;
+    transaction_hash: string;
+  };
+  ledger_hash: string;
+  ledger_index: number;
+  validated: boolean;
+} & ResponseStatus;

package/src/bridge/js.ts

@@ -0,0 +1,56 @@
+import {
+  makeAccountBridgeReceive,
+  defaultUpdateTransaction,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
+import { getAccountShape } from "../synchronization";
+import { buildSignOperation } from "../signOperation";
+import { XrpConfig, setCoinConfig } from "../config";
+import type { Transaction } from "../types";
+import { broadcast } from "../broadcast";
+import resolver from "../hw-getAddress";
+import { XrpSigner } from "../signer";
+
+export function createBridges(
+  signerContext: SignerContext<XrpSigner>,
+  coinConfig: () => XrpConfig,
+) {
+  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: defaultUpdateTransaction<Transaction>,
+    prepareTransaction,
+    getTransactionStatus,
+    estimateMaxSpendable,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

package/src/broadcast.ts

@@ -0,0 +1,20 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { Transaction } from "./types";
+import { submit } from "./api";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  const submittedPayment = await submit(signature);
+
+  if (
+    submittedPayment.engine_result !== "tesSUCCESS" &&
+    submittedPayment.engine_result !== "terQUEUED"
+  ) {
+    throw new Error(submittedPayment.engine_result_message);
+  }
+
+  const { hash } = submittedPayment.tx_json;
+  return patchOperationWithHash(operation, hash);
+};

package/src/cli-transaction.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import type { AccountLike } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+
+const options = [
+  {
+    name: "fee",
+    type: String,
+    desc: "how much fee",
+  },
+  {
+    name: "tag",
+    type: Number,
+    desc: "ripple tag",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: { tag?: number | null | undefined; fee?: string },
+  {
+    inferAmount,
+  }: { inferAmount: (account: AccountLike, fee?: string) => BigNumber | null | undefined },
+): Transaction[] {
+  return transactions.flatMap(({ transaction, account }) => {
+    invariant(transaction.family === "xrp", "XRP family");
+    return {
+      ...transaction,
+      fee: inferAmount(account, opts.fee || "0.001xrp"),
+      tag: opts.tag,
+    };
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/config.ts

@@ -0,0 +1,19 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type XrpConfig = CurrencyConfig & {
+  node: string;
+};
+
+let coinConfig: () => XrpConfig | undefined;
+
+export const setCoinConfig = (config: typeof coinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): XrpConfig => {
+  if (!coinConfig?.()) {
+    throw new Error("Xrp module config not set");
+  }
+
+  return coinConfig()!;
+};

package/src/createTransaction.ts

@@ -0,0 +1,13 @@
+import BigNumber from "bignumber.js";
+import { Transaction } from "./types";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  family: "xrp",
+  amount: new BigNumber(0),
+  recipient: "",
+  fee: null,
+  tag: undefined,
+  networkInfo: null,
+  feeCustomUnit: null,
+});

package/src/datasets/dataset-1.ts

@@ -0,0 +1,153 @@
+import BigNumber from "bignumber.js";
+import { DatasetTest } from "@ledgerhq/types-live";
+import { InvalidAddressBecauseDestinationIsAlsoSource } from "@ledgerhq/errors";
+import { fromTransactionRaw } from "../transaction";
+import { Transaction } from "../types";
+
+export const newAddress1 = "rZvBc5e2YR1A9otS3r9DyGh3NDP8XLLp4";
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["mock", "ripplejs"],
+  currencies: {
+    ripple: {
+      scanAccounts: [
+        {
+          name: "ripple seed 1",
+          unstableAccounts: true,
+          // our account is getting spammed...
+          apdus: `
+          => e00200400d038000002c8000009080000000
+          <= 2103c73f64083463fa923e1530af6f558204853873c6a45cbfb1f2f1e2ac2a5d989c2272734a4675764165634c333153513750594864504b6b3335625a456f78446d5231789000
+          => e002004015058000002c80000090800000000000000000000000
+          <= 2103d1adcff3e0cf1232b1416a75cd6f23b49dd6a25c69bc291a1f6783ec6825ec062272616765584842365134566276765764547a4b414e776a65435434485846434b58379000
+          => e002004015058000002c80000090800000010000000000000000
+          <= 21036da109ee84825eab0f55fb57bcf9ef0b05621e71fb0400266fb42d6f68f9487c2272425065393169766d67384347573450414e6f657555555173756d337470786a55469000
+          => e002004015058000002c80000090800000020000000000000000
+          <= 2102df9a55b79fb3668dac70fee7372806195841cd713ab8da9fba82240f9db8a23921725a76426335653259523141396f745333723944794768334e445038584c4c70349000
+          `,
+        },
+      ],
+      accounts: [
+        {
+          transactions: [
+            // FIXME
+
+            /*
+        {
+          name: "not enough spendable balance with base reserve",
+          transaction: fromTransactionRaw({
+            family: "xrp",
+            recipient: "rB6pwovsyrFWhPYUsjj9V3CHck985QjiXi",
+            amount: "15000000",
+            tag: null,
+            fee: "1",
+            feeCustomUnit: null,
+            networkInfo: null,
+          }),
+          expectedStatus: {
+            amount: BigNumber("15000000"),
+            estimatedFees: BigNumber("1"),
+            errors: {
+              amount: new NotEnoughSpendableBalance(null, {
+                minimumAmount: formatCurrencyUnit(
+                  rippleUnit,
+                  BigNumber("20"),
+                  {
+                    disableRounding: true,
+                    useGrouping: false,
+                    showCode: true,
+                  }
+                ),
+              }),
+            },
+            warnings: {},
+            totalSpent: BigNumber("15000001"),
+          },
+        },
+        */
+            // FIXME
+
+            /*
+        {
+          name: "operation amount to low to create the recipient account",
+          transaction: fromTransactionRaw({
+            family: "xrp",
+            recipient: newAddress1,
+            amount: "10000000",
+            tag: null,
+            fee: "1",
+            feeCustomUnit: null,
+            networkInfo: null
+          }),
+          expectedStatus: {
+            amount: BigNumber("10000000"),
+            estimatedFees: BigNumber("1"),
+            errors: {
+              amount: new NotEnoughBalanceBecauseDestinationNotCreated()
+            },
+            warnings: {},
+            totalSpent: BigNumber("10000001")
+          }
+        },
+        */
+            {
+              name: "recipient and sender must not be the same",
+              transaction: fromTransactionRaw({
+                family: "xrp",
+                recipient: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+                amount: "10000000",
+                tag: null,
+                fee: "1",
+                feeCustomUnit: null,
+                networkInfo: null,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("10000000"),
+                estimatedFees: new BigNumber("1"),
+                errors: {
+                  recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+                },
+                warnings: {},
+                totalSpent: new BigNumber("10000001"),
+              },
+            },
+            {
+              name: "Operation with tag succeed",
+              transaction: fromTransactionRaw({
+                family: "xrp",
+                recipient: "rB6pwovsyrFWhPYUsjj9V3CHck985QjiXi",
+                amount: "10000000",
+                tag: 12345,
+                fee: "1",
+                feeCustomUnit: null,
+                networkInfo: null,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("10000000"),
+                estimatedFees: new BigNumber("1"),
+                errors: {},
+                warnings: {},
+                totalSpent: new BigNumber("10000001"),
+              },
+            },
+          ],
+          raw: {
+            id: "ripplejs:2:ripple:rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7:",
+            seedIdentifier: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+            name: "XRP 1",
+            derivationMode: "",
+            index: 0,
+            freshAddress: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+            freshAddressPath: "44'/144'/0'/0/0",
+            blockHeight: 0,
+            operations: [],
+            pendingOperations: [],
+            currencyId: "ripple",
+            lastSyncDate: "",
+            balance: "21000310",
+          },
+        },
+      ],
+    },
+  },
+};

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,41 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "./types";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+
+function getDeviceTransactionConfig({
+  transaction: { tag },
+  status: { amount, estimatedFees },
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<CommonDeviceTransactionField> {
+  const fields: Array<CommonDeviceTransactionField> = [];
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  if (tag) {
+    fields.push({
+      type: "text",
+      label: "Tag",
+      value: tag ? String(tag) : "",
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/estimateMaxSpendable.ts

@@ -0,0 +1,25 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { Transaction } from "./types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const newTransaction = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    recipient: transaction?.recipient || getAbandonSeedAddress("ripple"),
+    // public testing seed abandonx11,about
+    amount: new BigNumber(0),
+  });
+  const status = await getTransactionStatus(mainAccount, newTransaction);
+  return BigNumber.max(0, account.spendableBalance.minus(status.estimatedFees));
+};