@ledgerhq/coin-xrp 7.5.1 → 7.6.0-nightly.0

package/src/logic/craftRawTransaction.ts

@@ -0,0 +1,91 @@
+import { CraftedTransaction } from "@ledgerhq/coin-framework/api/index";
+import { decode, encode } from "ripple-binary-codec";
+import { getLedgerIndex } from "../network";
+import { estimateFees } from "./estimateFees";
+import { JsonObject } from "ripple-binary-codec/dist/types/serialized-type";
+import { SignerEntry } from "../types";
+import { sortSignersByNumericAddress } from "./utils";
+
+const LEDGER_OFFSET = 20;
+
+function craftRawTransactionMultiSign(
+  xrplTransaction: JsonObject,
+  sender: string,
+  publicKey: string,
+): CraftedTransaction {
+  if (!xrplTransaction.Fee) {
+    throw new Error("Fee is required for multi sign transactions");
+  }
+  if (!xrplTransaction.Sequence) {
+    throw new Error("Sequence is required for multi sign transactions");
+  }
+
+  const signer: SignerEntry = {
+    Signer: {
+      Account: sender,
+      SigningPubKey: publicKey,
+      TxnSignature: "",
+    },
+  };
+
+  if (!xrplTransaction.Signers || !Array.isArray(xrplTransaction.Signers)) {
+    xrplTransaction.Signers = [signer];
+  } else {
+    xrplTransaction.Signers.push(signer);
+    // The Signers array must be sorted based on the numeric value of the signer addresses
+    // We could probably insert it at the right place directly but like this we make sure the rest is also sorted
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    xrplTransaction.Signers = sortSignersByNumericAddress(xrplTransaction.Signers as SignerEntry[]);
+  }
+
+  const serializedTransaction = encode(xrplTransaction);
+
+  return { transaction: serializedTransaction };
+}
+
+export async function craftRawTransaction(
+  transaction: string,
+  sender: string,
+  publicKey: string,
+  sequence: number,
+): Promise<CraftedTransaction> {
+  const xrplTransaction: JsonObject = decode(transaction);
+
+  // Multi sign transactions have an empty SigningPubKey
+  // We only check some of the fields and cannot autofill others
+  // The sender cannot be checked because the transaction can be signed by another account
+  // https://xrpl.org/docs/concepts/accounts/multi-signing#sending-multi-signed-transactions
+  // https://xrpl.org/docs/tutorials/how-tos/manage-account-settings/send-a-multi-signed-transaction
+  if (xrplTransaction.SigningPubKey === "") {
+    return craftRawTransactionMultiSign(xrplTransaction, sender, publicKey);
+  }
+
+  if (sender !== xrplTransaction.Account) {
+    throw new Error("Sender address does not match the transaction account");
+  }
+
+  if (!xrplTransaction.Fee) {
+    const { fees } = await estimateFees();
+    xrplTransaction.Fee = fees.toString();
+  }
+
+  // Enforce XRPL spec: If TicketSequence is provided, Sequence MUST be 0 regardless of any pre-set value.
+  // https://xrpl.org/docs/references/protocol/transactions/common-fields#transaction-common-fields
+  if (xrplTransaction.TicketSequence) {
+    xrplTransaction.Sequence = 0;
+  } else if (!xrplTransaction.Sequence) {
+    xrplTransaction.Sequence = sequence;
+  }
+
+  if (!xrplTransaction.LastLedgerSequence) {
+    xrplTransaction.LastLedgerSequence = (await getLedgerIndex()) + LEDGER_OFFSET;
+  }
+
+  if (!xrplTransaction.SigningPubKey) {
+    xrplTransaction.SigningPubKey = publicKey;
+  }
+
+  const serializedTransaction = encode(xrplTransaction);
+
+  return { transaction: serializedTransaction };
+}

package/src/logic/index.ts

@@ -1,6 +1,7 @@
 export { broadcast } from "./broadcast";
 export { combine } from "./combine";
 export { craftTransaction } from "./craftTransaction";
+export { craftRawTransaction } from "./craftRawTransaction";
 export type { MemoInput } from "./craftTransaction";
 export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";

package/src/logic/utils.test.ts

@@ -1,7 +1,20 @@
-import { cachedRecipientIsNew } from "./utils";
+import { cachedRecipientIsNew, sortSignersByNumericAddress } from "./utils";
+import { SignerEntry } from "../types";
+
+// We'll mock ripple-address-codec so that we control numeric ordering via decodeAccountID
+// without re-implementing the util's logic inside the tests.
+const decodeAccountIDMock = jest.fn((account: string) => {
+  // Provide deterministic 20-byte arrays whose last byte encodes the numeric ordering.
+  // (Big-endian comparison means earlier bytes are 0; ordering driven by final byte value.)
+  const bytes = new Uint8Array(20).fill(0);
+  const ordering: Record<string, number> = { alpha: 1, gamma: 2, beta: 3, epsilon: 4, delta: 5 };
+  if (ordering[account]) bytes[19] = ordering[account];
+  return bytes;
+});
 
 jest.mock("ripple-address-codec", () => ({
   isValidClassicAddress: () => true,
+  decodeAccountID: (address: string) => decodeAccountIDMock(address),
 }));
 const mockGetAccountInfo = jest.fn();
 jest.mock("../network", () => ({
@@ -58,3 +71,60 @@ describe("cachedRecipientIsNew", () => {
     expect(mockGetAccountInfo).toHaveBeenCalledTimes(1);
   });
 });
+
+// Helper to build a SignerEntry from an Account address
+function signer(account: string): SignerEntry {
+  return {
+    Signer: {
+      Account: account,
+      SigningPubKey: "PUBKEY",
+      TxnSignature: "SIGNATURE",
+    },
+  };
+}
+
+// We intentionally use simple string identifiers (not real XRP addresses) since we fully mock decodeAccountID.
+// Numeric order (smallest->largest) encoded in mock via last byte value: alpha(1), gamma(2), beta(3), epsilon(4), delta(5)
+const orderedByNumeric = ["alpha", "gamma", "beta", "epsilon", "delta"];
+
+describe("sortSignersByNumericAddress", () => {
+  it("returns an empty array when given an empty array", () => {
+    expect(sortSignersByNumericAddress([])).toEqual([]);
+  });
+
+  it("does not mutate the original array", () => {
+    const original: SignerEntry[] = [signer("beta"), signer("alpha"), signer("delta")];
+    const originalSnapshot = original.map(s => s.Signer.Account);
+    const result = sortSignersByNumericAddress(original);
+    expect(result).not.toBe(original);
+    expect(original.map(s => s.Signer.Account)).toEqual(originalSnapshot);
+  });
+
+  it("returns new array for single element", () => {
+    const single = [signer("alpha")];
+    const result = sortSignersByNumericAddress(single);
+    expect(result).toHaveLength(1);
+    expect(result[0].Signer.Account).toBe("alpha");
+    expect(result).not.toBe(single);
+  });
+
+  it("sorts by numeric account ID as provided by decodeAccountID mock", () => {
+    const shuffled = ["delta", "gamma", "alpha", "epsilon", "beta"]; // random order
+    const signers = shuffled.map(a => signer(a));
+    const result = sortSignersByNumericAddress(signers).map(s => s.Signer.Account);
+    expect(result).toEqual(orderedByNumeric);
+    // Ensure decodeAccountID was called for each element at least once
+    orderedByNumeric.forEach(addr => {
+      expect(decodeAccountIDMock).toHaveBeenCalledWith(addr);
+    });
+  });
+
+  it("ordering differs from naive lexicographic string sort", () => {
+    const signers = ["alpha", "beta", "delta", "epsilon", "gamma"].map(a => signer(a));
+    const numericSorted = sortSignersByNumericAddress(signers).map(s => s.Signer.Account);
+    const lexSorted = signers.map(s => s.Signer.Account).sort();
+    // Our predetermined numeric order should not equal simple lexical sort (which puts beta before gamma)
+    expect(numericSorted).toEqual(orderedByNumeric);
+    expect(numericSorted).not.toEqual(lexSorted);
+  });
+});

package/src/logic/utils.ts

@@ -1,6 +1,7 @@
 import BigNumber from "bignumber.js";
-import { isValidClassicAddress } from "ripple-address-codec";
+import { decodeAccountID, isValidClassicAddress } from "ripple-address-codec";
 import { getAccountInfo } from "../network";
+import { SignerEntry } from "../types";
 
 export const UINT32_MAX = new BigNumber(2).pow(32).minus(1);
 
@@ -54,3 +55,21 @@ export const cachedRecipientIsNew = async (recipient: string): Promise<boolean>
 
   return isNew;
 };
+
+/**
+ * Sorts the Signers array by the numeric value of each Signer.Account address.
+ * The numeric value is the big-endian integer of the 20-byte account ID.
+ */
+export function sortSignersByNumericAddress(signers: SignerEntry[]): SignerEntry[] {
+  return signers.slice().sort((a, b) => {
+    const aBytes = decodeAccountID(a.Signer.Account);
+    const bBytes = decodeAccountID(b.Signer.Account);
+
+    const aInt = BigInt("0x" + Buffer.from(aBytes).toString("hex"));
+    const bInt = BigInt("0x" + Buffer.from(bBytes).toString("hex"));
+
+    if (aInt > bInt) return 1;
+    if (aInt < bInt) return -1;
+    return 0;
+  });
+}

package/src/logic/validateIntent.test.ts

@@ -50,6 +50,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 20_000_000n,
         recipient: RECIPIENT,
@@ -84,6 +85,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 1_000_000n,
         recipient: RECIPIENT,
@@ -117,6 +119,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 10_000_000n,
         recipient: RECIPIENT,
@@ -146,6 +149,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 10_000_000n,
         recipient: SENDER,
@@ -176,6 +180,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 5_000_000n,
         recipient: RECIPIENT_NEW,
@@ -206,6 +211,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         amount: 0n,
         recipient: RECIPIENT,
@@ -236,6 +242,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         asset: { unit: { code: "XRP", magnitude: 6 } },
         amount: 1_000_000n,
@@ -266,6 +273,7 @@ describe("validateIntent", () => {
     const result = await validateIntent(
       // account as any,
       {
+        intentType: "transaction",
         sender: SENDER,
         asset: { unit: { code: "XRP", magnitude: 6 } },
         amount: 1_000_000n,

package/src/types/model.ts

@@ -31,3 +31,11 @@ export type ListOperationsOptions = {
   // filters:
   minHeight?: number;
 };
+
+export type SignerEntry = {
+  Signer: {
+    Account: string;
+    SigningPubKey: string;
+    TxnSignature: string;
+  };
+};