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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-xrp",
-  "version": "7.5.1",
+  "version": "7.6.0-nightly.1",
   "description": "Ledger XRP Coin integration",
   "keywords": [
     "Ledger",
@@ -103,12 +103,12 @@
     "invariant": "^2.2.4",
     "ripple-address-codec": "^5.0.0",
     "ripple-binary-codec": "^1.3.0",
-    "@ledgerhq/coin-framework": "^6.6.0",
-    "@ledgerhq/cryptoassets": "^13.30.0",
-    "@ledgerhq/devices": "8.6.1",
+    "@ledgerhq/coin-framework": "^6.7.0-nightly.1",
+    "@ledgerhq/cryptoassets": "^13.31.0-nightly.1",
     "@ledgerhq/errors": "^6.26.0",
-    "@ledgerhq/live-network": "^2.0.19",
-    "@ledgerhq/types-live": "^6.86.0",
+    "@ledgerhq/devices": "8.6.1",
+    "@ledgerhq/live-network": "^2.0.20-nightly.0",
+    "@ledgerhq/types-live": "^6.87.0-nightly.1",
     "@ledgerhq/logs": "^6.13.0"
   },
   "devDependencies": {
@@ -122,7 +122,7 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.4.5",
     "@ledgerhq/disable-network-setup": "^0.0.0",
-    "@ledgerhq/types-cryptoassets": "^7.28.0"
+    "@ledgerhq/types-cryptoassets": "^7.29.0-nightly.0"
   },
   "scripts": {
     "clean": "rimraf lib lib-es",

package/src/api/index.integ.test.ts

@@ -15,6 +15,7 @@ describe("Xrp Api (testnet)", () => {
 
       // When
       const result = await api.estimateFees({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -125,6 +126,7 @@ describe("Xrp Api (testnet)", () => {
     it("returns a raw transaction", async () => {
       // When
       const { transaction: result } = await api.craftTransaction({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -141,6 +143,7 @@ describe("Xrp Api (testnet)", () => {
 
     it("should use default fees when user does not provide them for crafting a transaction", async () => {
       const { transaction: result } = await api.craftTransaction({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -161,6 +164,7 @@ describe("Xrp Api (testnet)", () => {
       const customFees = 99n;
       const { transaction: result } = await api.craftTransaction(
         {
+          intentType: "transaction",
           asset: { type: "native" },
           type: "send",
           sender: SENDER,
@@ -192,6 +196,7 @@ describe("Xrp Api (mainnet)", () => {
 
       // When
       const result = await api.estimateFees({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -289,6 +294,7 @@ describe("Xrp Api (mainnet)", () => {
 
     it("returns a raw transaction", async () => {
       const { transaction: result } = await api.craftTransaction({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -304,6 +310,7 @@ describe("Xrp Api (mainnet)", () => {
 
     it("should use default fees when user does not provide them for crafting a transaction", async () => {
       const { transaction: result } = await api.craftTransaction({
+        intentType: "transaction",
         asset: { type: "native" },
         type: "send",
         sender: SENDER,
@@ -324,6 +331,7 @@ describe("Xrp Api (mainnet)", () => {
       const customFees = 99n;
       const { transaction: result } = await api.craftTransaction(
         {
+          intentType: "transaction",
           asset: { type: "native" },
           type: "send",
           sender: SENDER,

package/src/api/index.test.ts

@@ -1,4 +1,4 @@
-import { Operation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { Operation, SendTransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import * as LogicFunctions from "../logic";
 import { GetTransactionsOptions } from "../network";
 import { NetworkInfo, XrpMapMemo } from "../types";
@@ -280,9 +280,12 @@ describe("Testing craftTransaction function", () => {
 
   it("should use custom user fees when user provides it for crafting a transaction", async () => {
     const customFees = 99n;
-    await api.craftTransaction({ sender: "foo" } as TransactionIntent<XrpMapMemo>, {
-      value: customFees,
-    });
+    await api.craftTransaction(
+      { intentType: "transaction", sender: "foo" } as SendTransactionIntent<XrpMapMemo>,
+      {
+        value: customFees,
+      },
+    );
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -294,7 +297,10 @@ describe("Testing craftTransaction function", () => {
   });
 
   it("should use default fees when user does not provide them for crafting a transaction", async () => {
-    await api.craftTransaction({ sender: "foo" } as TransactionIntent<XrpMapMemo>);
+    await api.craftTransaction({
+      intentType: "transaction",
+      sender: "foo",
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -307,9 +313,10 @@ describe("Testing craftTransaction function", () => {
 
   it("should pass signing pub key when user provides it for crafting a transaction", async () => {
     await api.craftTransaction({
+      intentType: "transaction",
       sender: "foo",
       senderPublicKey: "bar",
-    } as TransactionIntent<XrpMapMemo>);
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -320,12 +327,13 @@ describe("Testing craftTransaction function", () => {
 
   it("should pass memos when user provides it for crafting a transaction", async () => {
     await api.craftTransaction({
+      intentType: "transaction",
       sender: "foo",
       memo: {
         type: "map",
         memos: new Map([["memos", ["testdata"]]]),
       },
-    } as TransactionIntent<XrpMapMemo>);
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -340,8 +348,9 @@ describe("Testing craftTransaction function", () => {
 
   it("should not pass memos when user does not provide it for crafting a transaction", async () => {
     await api.craftTransaction({
+      intentType: "transaction",
       sender: "foo",
-    } as TransactionIntent<XrpMapMemo>);
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -354,12 +363,13 @@ describe("Testing craftTransaction function", () => {
 
   it("should not pass memos when user provides an empty memo list it for crafting a transaction", async () => {
     await api.craftTransaction({
+      intentType: "transaction",
       sender: "foo",
       memo: {
         type: "map",
         memos: new Map(),
       },
-    } as TransactionIntent<XrpMapMemo>);
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),
@@ -372,12 +382,13 @@ describe("Testing craftTransaction function", () => {
 
   it("should pass destination tag when user provides it for crafting a transaction", async () => {
     await api.craftTransaction({
+      intentType: "transaction",
       sender: "foo",
       memo: {
         type: "map",
         memos: new Map([["destinationTag", "1337"]]),
       },
-    } as TransactionIntent<XrpMapMemo>);
+    } as SendTransactionIntent<XrpMapMemo>);
 
     expect(logicCraftTransactionSpy).toHaveBeenCalledWith(
       expect.any(Object),

package/src/api/index.ts

@@ -12,12 +12,14 @@ import {
   TransactionIntent,
   CraftedTransaction,
 } from "@ledgerhq/coin-framework/api/index";
+import { isSendTransactionIntent } from "@ledgerhq/coin-framework/utils";
 import { log } from "@ledgerhq/logs";
 import coinConfig, { type XrpConfig } from "../config";
 import {
   broadcast,
   combine,
   craftTransaction,
+  craftRawTransaction,
   estimateFees,
   getBalance,
   getAccountInfo,
@@ -36,6 +38,7 @@ export function createApi(config: XrpConfig): Api<XrpMapMemo> {
     broadcast,
     combine,
     craftTransaction: craft,
+    craftRawTransaction,
     estimateFees: estimate,
     getBalance,
     lastBlock,
@@ -64,6 +67,9 @@ async function craft(
   transactionIntent: TransactionIntent<XrpMapMemo>,
   customFees?: FeeEstimation,
 ): Promise<CraftedTransaction> {
+  if (isSendTransactionIntent(transactionIntent) === false) {
+    throw new Error("Only transaction intentType is supported");
+  }
   const nextSequenceNumber = await getNextValidSequence(transactionIntent.sender);
   const estimatedFees = customFees?.value ?? (await estimateFees()).fees;
 

package/src/logic/combine.ts

@@ -1,18 +1,38 @@
 import { decode, encode } from "ripple-binary-codec";
 import { JsonObject } from "ripple-binary-codec/dist/types/serialized-type";
+import { SignerEntry } from "../types";
 
 type XRPTransaction = JsonObject & {
-  TxnSignature: string;
+  Signers?: Array<SignerEntry>;
+  TxnSignature?: string;
   SigningPubKey?: string;
 };
 
 export function combine(transaction: string, signature: string, publicKey?: string): string {
-  const xrplTransaction: JsonObject = decode(transaction);
-  let transactionWithSignature: XRPTransaction = { ...xrplTransaction, TxnSignature: signature };
+  const xrplTransaction: XRPTransaction = decode(transaction);
 
-  if (publicKey) {
-    transactionWithSignature = { ...transactionWithSignature, SigningPubKey: publicKey };
+  // Multi sign transactions have an empty SigningPubKey
+  // 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 === "") {
+    // Find the signer that still needs a signature. If a publicKey is provided, match it;
+    // otherwise take the first signer without a TxnSignature.
+    const signerEntry = xrplTransaction.Signers?.find(
+      s => s.Signer.TxnSignature === "" && (!publicKey || s.Signer.SigningPubKey === publicKey),
+    );
+
+    if (signerEntry) {
+      signerEntry.Signer.TxnSignature = signature;
+    }
+
+    return encode(xrplTransaction);
+  }
+
+  xrplTransaction.TxnSignature = signature;
+
+  if (publicKey && !xrplTransaction.SigningPubKey) {
+    xrplTransaction.SigningPubKey = publicKey;
   }
 
-  return encode(transactionWithSignature);
+  return encode(xrplTransaction);
 }

package/src/logic/craftRawTransaction.test.ts

@@ -0,0 +1,362 @@
+import { craftRawTransaction } from "./craftRawTransaction";
+import { encode, decode } from "ripple-binary-codec";
+import { SignerEntry } from "../types";
+
+// --- Mocks ---
+const mockEstimateFees = jest.fn();
+const mockGetLedgerIndex = jest.fn();
+
+jest.mock("./estimateFees", () => ({
+  estimateFees: () => mockEstimateFees(),
+}));
+
+jest.mock("../network", () => ({
+  getLedgerIndex: () => mockGetLedgerIndex(),
+}));
+
+// Mock ripple-address-codec globally so ordering logic in sortSignersByNumericAddress uses deterministic data.
+const decodeAccountIDMock = jest.fn((account: string) => {
+  const bytes = new Uint8Array(20).fill(0);
+  const ordering: Record<string, number> = { alpha: 1, beta: 2, gamma: 3, delta: 4 };
+  if (ordering[account]) bytes[19] = ordering[account];
+  return bytes;
+});
+jest.mock("ripple-address-codec", () => ({
+  decodeAccountID: (addr: string) => decodeAccountIDMock(addr),
+  isValidClassicAddress: () => true,
+}));
+
+describe("craftRawTransaction", () => {
+  const sender = "rPDf6SQStnNmw1knCu1ei7h6BcDAEUUqn5";
+  const destination = "rJe1St1G6BWMFmdrrcT7NdD3XT1NxTMEWN";
+  // XRPL Ed25519 public keys must be 33 bytes: 0xED prefix + 32 bytes payload (66 hex chars total)
+  // Using a deterministic dummy key so ripple-binary-codec encode/decode roundtrips without alteration.
+  const publicKey = "ED0123456789ABCDEFFEDCBA98765432100123456789ABCDEFFEDCBA9876543211"; // 66 hex chars
+  // Pre-set key used in the test that ensures existing SigningPubKey is preserved.
+  const alreadySetPublicKey = "EDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"; // 66 hex chars
+
+  beforeEach(() => {
+    mockEstimateFees.mockReset();
+    mockGetLedgerIndex.mockReset();
+  });
+
+  // Helper to safely extract Signers array without relying on type assertions elsewhere
+  function getSigners(obj: unknown): SignerEntry[] | undefined {
+    if (!obj || typeof obj !== "object") return undefined;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const potential = (obj as { Signers?: unknown }).Signers;
+    if (Array.isArray(potential)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return potential as SignerEntry[];
+    }
+    return undefined;
+  }
+
+  it("fills missing Fee, Sequence, LastLedgerSequence & SigningPubKey for a standard payment", async () => {
+    // Given: base transaction missing common autofill fields
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "1000",
+      Destination: destination,
+    } as const;
+    const serialized = encode(baseTx);
+
+    mockEstimateFees.mockResolvedValue({ fees: BigInt(123) });
+    mockGetLedgerIndex.mockResolvedValue(1000);
+
+    // When
+    const result = await craftRawTransaction(serialized, sender, publicKey, 10);
+
+    // Then
+    const decoded = decode(result.transaction);
+    expect(decoded).toMatchObject({
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "1000",
+      Destination: destination,
+      Fee: "123",
+      Sequence: 10,
+      LastLedgerSequence: 1020, // 1000 + 20 offset
+      SigningPubKey: publicKey,
+    });
+    expect(mockEstimateFees).toHaveBeenCalledTimes(1);
+    expect(mockGetLedgerIndex).toHaveBeenCalledTimes(1);
+  });
+
+  it("autofills only missing Fee & LastLedgerSequence when Sequence provided", async () => {
+    // Given: Sequence present; Fee, LastLedgerSequence & SigningPubKey missing
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "1234",
+      Destination: destination,
+      Sequence: 77,
+    } as const;
+    const serialized = encode(baseTx);
+
+    mockEstimateFees.mockResolvedValue({ fees: BigInt(456) });
+    mockGetLedgerIndex.mockResolvedValue(2000);
+
+    // When: pass a different sequence param to ensure existing Sequence is not overwritten
+    const result = await craftRawTransaction(serialized, sender, publicKey, 999);
+
+    // Then
+    const decoded = decode(result.transaction);
+    expect(decoded.Sequence).toBe(77); // preserved
+    expect(decoded.Fee).toBe("456"); // autofilled
+    expect(decoded.LastLedgerSequence).toBe(2020); // 2000 + 20
+    expect(decoded.SigningPubKey).toBe(publicKey); // autofilled
+    expect(mockEstimateFees).toHaveBeenCalledTimes(1);
+    expect(mockGetLedgerIndex).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not overwrite provided Fee / Sequence / LastLedgerSequence / SigningPubKey", async () => {
+    // Given
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "2500",
+      Destination: destination,
+      Fee: "999",
+      Sequence: 42,
+      LastLedgerSequence: 5000,
+      SigningPubKey: alreadySetPublicKey,
+    } as const;
+    const serialized = encode(baseTx);
+
+    // Mocks would be used if fields missing; ensure they are ignored
+    mockEstimateFees.mockResolvedValue({ fees: BigInt(1) });
+    mockGetLedgerIndex.mockResolvedValue(1);
+
+    // When
+    const result = await craftRawTransaction(serialized, sender, publicKey, 999);
+
+    // Then
+    const decoded = decode(result.transaction);
+    expect(decoded.Fee).toBe("999");
+    expect(decoded.Sequence).toBe(42);
+    expect(decoded.LastLedgerSequence).toBe(5000);
+    expect(decoded.SigningPubKey).toBe(alreadySetPublicKey);
+    expect(mockEstimateFees).not.toHaveBeenCalled();
+    expect(mockGetLedgerIndex).not.toHaveBeenCalled();
+  });
+
+  it("sets Sequence to 0 when TicketSequence is provided and Sequence missing", async () => {
+    // Given
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "1",
+      Destination: destination,
+      TicketSequence: 555,
+      Fee: "10",
+      // Sequence intentionally omitted
+    } as const;
+    const serialized = encode(baseTx);
+
+    mockGetLedgerIndex.mockResolvedValue(10);
+
+    // When
+    const result = await craftRawTransaction(serialized, sender, publicKey, 77);
+
+    // Then
+    const decoded = decode(result.transaction);
+    expect(decoded.TicketSequence).toBe(555);
+    expect(decoded.Sequence).toBe(0);
+    expect(decoded.LastLedgerSequence).toBe(30); // 10 + 20
+  });
+
+  it("forces Sequence to 0 when TicketSequence present even if non-zero Sequence provided", async () => {
+    // Given: TicketSequence provided AND a non-zero Sequence already set (we enforce spec by overriding)
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "123",
+      Destination: destination,
+      TicketSequence: 777,
+      Sequence: 55, // non-zero pre-set
+      Fee: "10",
+    } as const;
+    const serialized = encode(baseTx);
+
+    mockGetLedgerIndex.mockResolvedValue(111);
+
+    // When
+    const result = await craftRawTransaction(serialized, sender, publicKey, 9999);
+
+    // Then
+    const decoded = decode(result.transaction);
+    expect(decoded.Sequence).toBe(0); // overridden to comply with spec
+    expect(decoded.TicketSequence).toBe(777);
+    expect(decoded.LastLedgerSequence).toBe(131); // 111 + 20
+  });
+
+  it("throws when sender does not match Account for standard transaction", async () => {
+    // Given
+    const baseTx = {
+      TransactionType: "Payment",
+      Account: sender,
+      Amount: "10",
+      Destination: destination,
+    } as const;
+    const serialized = encode(baseTx);
+
+    // When & Then
+    await expect(craftRawTransaction(serialized, "rOTHERADDRESS", publicKey, 1)).rejects.toThrow(
+      "Sender address does not match the transaction account",
+    );
+  });
+
+  describe("multi-sign", () => {
+    it("adds a Signers array when absent (single existing signer)", async () => {
+      // Given: multi-sign transaction (SigningPubKey empty) with required Fee & Sequence
+      const multi = {
+        TransactionType: "Payment",
+        Account: sender, // Account can differ from signer in multi-sign, we keep same for simplicity
+        Amount: "100",
+        Destination: destination,
+        SigningPubKey: "", // signals multi-sign
+        Fee: "500",
+        Sequence: 9,
+      } as const;
+      const serialized = encode(multi);
+
+      // When
+      const result = await craftRawTransaction(serialized, sender, publicKey, 9);
+
+      // Then
+      const decoded = decode(result.transaction);
+      const signers = getSigners(decoded);
+      expect(signers?.length).toBe(1);
+      if (signers && signers[0]) {
+        expect(signers[0]).toMatchObject({
+          Signer: { Account: sender, SigningPubKey: publicKey, TxnSignature: "" },
+        });
+      }
+      // No autofill of LastLedgerSequence in multi-sign path (not required for this assertion)
+    });
+
+    it("does not add LastLedgerSequence for multi-sign when absent", async () => {
+      // Given: multi-sign tx w/o LastLedgerSequence
+      const multi = {
+        TransactionType: "Payment",
+        Account: sender,
+        Amount: "50",
+        Destination: destination,
+        SigningPubKey: "", // multi-sign
+        Fee: "12",
+        Sequence: 2,
+      } as const;
+      const serialized = encode(multi);
+      mockGetLedgerIndex.mockResolvedValue(500); // should NOT be used
+
+      // When
+      const result = await craftRawTransaction(serialized, sender, publicKey, 2);
+
+      // Then
+      const decoded = decode(result.transaction);
+      expect(decoded.LastLedgerSequence).toBeUndefined();
+    });
+
+    it("appends signer and sorts existing Signers numerically", async () => {
+      // Given existing unsorted signers
+      const existing: SignerEntry[] = [
+        {
+          Signer: {
+            Account: "rPDf6SQStnNmw1knCu1ei7h6BcDAEUUqn5",
+            SigningPubKey: "K3",
+            TxnSignature: "",
+          },
+        },
+        {
+          Signer: {
+            Account: "rJe1St1G6BWMFmdrrcT7NdD3XT1NxTMEWN",
+            SigningPubKey: "K1",
+            TxnSignature: "",
+          },
+        },
+        {
+          Signer: {
+            Account: "rDKsbvy9uaNpPtvVFraJyNGfjvTw8xivgK",
+            SigningPubKey: "K4",
+            TxnSignature: "",
+          },
+        },
+      ];
+      const multi: {
+        TransactionType: string;
+        Account: string;
+        Amount: string;
+        Destination: string;
+        SigningPubKey: string;
+        Fee: string;
+        Sequence: number;
+        Signers: SignerEntry[];
+      } = {
+        TransactionType: "Payment",
+        Account: sender,
+        Amount: "200",
+        Destination: destination,
+        SigningPubKey: "",
+        Fee: "700",
+        Sequence: 3,
+        Signers: existing,
+      };
+      const serialized = encode(multi);
+
+      // When
+      const result = await craftRawTransaction(
+        serialized,
+        "r94uo44ukDHWVjYDJLZJYwDdZjo1F2QYgq",
+        publicKey,
+        3,
+      );
+
+      // Then
+      const decoded = decode(result.transaction);
+      const signers = getSigners(decoded) ?? [];
+      const accounts = signers.map(s => s.Signer.Account);
+      expect(accounts).toEqual([
+        "rPDf6SQStnNmw1knCu1ei7h6BcDAEUUqn5",
+        "rJe1St1G6BWMFmdrrcT7NdD3XT1NxTMEWN",
+        "rDKsbvy9uaNpPtvVFraJyNGfjvTw8xivgK",
+        "r94uo44ukDHWVjYDJLZJYwDdZjo1F2QYgq",
+      ]);
+      const betaEntry = signers.find(
+        s => s.Signer.Account === "r94uo44ukDHWVjYDJLZJYwDdZjo1F2QYgq",
+      );
+      expect(betaEntry?.Signer.SigningPubKey).toBe(publicKey);
+    });
+
+    it("throws when Fee missing for multi-sign", async () => {
+      const multi = {
+        TransactionType: "Payment",
+        Account: sender,
+        Amount: "10",
+        Destination: destination,
+        SigningPubKey: "",
+        Sequence: 1,
+      } as const;
+      const serialized = encode(multi);
+      await expect(craftRawTransaction(serialized, sender, publicKey, 1)).rejects.toThrow(
+        "Fee is required for multi sign transactions",
+      );
+    });
+
+    it("throws when Sequence missing for multi-sign", async () => {
+      const multi = {
+        TransactionType: "Payment",
+        Account: sender,
+        Amount: "10",
+        Destination: destination,
+        SigningPubKey: "",
+        Fee: "1",
+      } as const;
+      const serialized = encode(multi);
+      await expect(craftRawTransaction(serialized, sender, publicKey, 1)).rejects.toThrow(
+        "Sequence is required for multi sign transactions",
+      );
+    });
+  });
+});