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

package/src/api/index.ts

@@ -16,11 +16,11 @@ import {
   getNextValidSequence,
   lastBlock,
   listOperations,
-  MemoInput,
+  getTransactionStatus,
 } from "../logic";
-import { ListOperationsOptions, XrpAsset } from "../types";
+import { ListOperationsOptions, XrpAsset, XrpMapMemo } from "../types";
 
-export function createApi(config: XrpConfig): Api<XrpAsset, TransactionIntentExtra, XrpSender> {
+export function createApi(config: XrpConfig): Api<XrpAsset, XrpMapMemo> {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
 
   return {
@@ -31,36 +31,45 @@ export function createApi(config: XrpConfig): Api<XrpAsset, TransactionIntentExt
     getBalance,
     lastBlock,
     listOperations: operations,
+    validateIntent: getTransactionStatus,
   };
 }
 
-export type TransactionIntentExtra = {
-  destinationTag?: number | null | undefined;
-  memos?: MemoInput[];
-};
-
-export type XrpSender = {
-  address: string;
-  publicKey?: string;
-};
-
 async function craft(
-  transactionIntent: TransactionIntent<XrpAsset, TransactionIntentExtra, XrpSender>,
+  transactionIntent: TransactionIntent<XrpAsset, XrpMapMemo>,
   customFees?: bigint,
 ): Promise<string> {
-  const nextSequenceNumber = await getNextValidSequence(transactionIntent.sender.address);
+  const nextSequenceNumber = await getNextValidSequence(transactionIntent.sender);
   const estimatedFees = customFees !== undefined ? customFees : (await estimateFees()).fee;
+
+  const memosMap =
+    transactionIntent.memo?.type === "map" ? transactionIntent.memo.memos : new Map();
+
+  const destinationTagValue = memosMap.get("destinationTag");
+  const destinationTag =
+    typeof destinationTagValue === "string" ? Number(destinationTagValue) : undefined;
+
+  const memoStrings = memosMap.get("memos") as string[] | undefined;
+
+  let memoEntries: { type: string; data: string }[] = [];
+
+  if (Array.isArray(memoStrings) && memoStrings.length > 0) {
+    memoEntries = memoStrings.map(value => ({ type: "memo", data: value }));
+  }
+
   const tx = await craftTransaction(
-    { address: transactionIntent.sender.address, nextSequenceNumber },
+    { address: transactionIntent.sender, nextSequenceNumber },
     {
       recipient: transactionIntent.recipient,
       amount: transactionIntent.amount,
       fee: estimatedFees,
-      destinationTag: transactionIntent.destinationTag,
-      memos: transactionIntent.memos,
+      destinationTag,
+      // NOTE: double check before/after here
+      memos: memoEntries,
     },
-    transactionIntent.sender.publicKey,
+    transactionIntent.senderPublicKey,
   );
+
   return tx.serializedTransaction;
 }
 

package/src/index.ts

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

package/src/logic/combine.ts

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

package/src/logic/getBalance.test.ts

@@ -2,21 +2,33 @@ 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
@@ -24,7 +36,8 @@ 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" } }]);
+    expect(result).toEqual([{ value: balance, asset: { type: "native" }, locked: 23000000n }]);
   });
 });

package/src/logic/getBalance.ts

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

package/src/logic/getTransactionStatus.test.ts

@@ -0,0 +1,215 @@
+import { getTransactionStatus } from "./getTransactionStatus";
+import * as logic from "./index";
+
+const mockGetServerInfos = jest.fn();
+const mockCachedRecipientIsNew = jest.fn();
+
+jest.mock("../network", () => ({
+  getServerInfos: () => mockGetServerInfos(),
+}));
+
+jest.spyOn(logic, "cachedRecipientIsNew").mockImplementation(addr => {
+  if (addr === RECIPIENT_NEW) {
+    return Promise.resolve(true);
+  }
+  return Promise.resolve(false);
+});
+
+const reserveBase = 10_000_000n; // 10 XRP (drops)
+
+const SENDER = "rPSCfmnX3t9jQJG5RNcZtSaP5UhExZDue4";
+const RECIPIENT = "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe";
+const RECIPIENT_NEW = "rDKsbvy9uaNpPtvVFraJyNGfjvTw8xivgK";
+
+const account = {
+  address: SENDER,
+  balance: 50_000_000n,
+  currencyUnit: {
+    code: "XRP",
+    magnitude: 6,
+    name: "XRP",
+    symbol: "XRP",
+  },
+  currencyName: "XRP",
+};
+
+describe("getTransactionStatus", () => {
+  afterEach(() => {
+    mockGetServerInfos.mockReset();
+    mockCachedRecipientIsNew.mockReset();
+  });
+
+  it("returns no errors on valid transaction", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n, // XRP value, not drops
+        },
+      },
+    });
+
+    mockCachedRecipientIsNew.mockResolvedValue(false);
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 20_000_000n,
+        fee: 10_000n,
+        recipient: RECIPIENT,
+      } as any,
+    );
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.totalSpent).toBe(20_010_000n);
+  });
+
+  it("throws FeeTooHigh warning when fee is >10% of amount", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 1_000_000n,
+        fee: 200_000n, // 20%
+        recipient: RECIPIENT,
+      } as any,
+    );
+
+    expect(result.warnings.feeTooHigh).toBeInstanceOf(Error);
+    expect(result.errors).toEqual({});
+  });
+
+  it("errors when fee is missing", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 10_000_000n,
+        recipient: RECIPIENT,
+      } as any,
+    );
+
+    expect(result.errors.fee?.name).toBe("FeeNotLoaded");
+  });
+
+  it("errors if recipient is same as sender", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 10_000_000n,
+        fee: 10_000n,
+        recipient: SENDER,
+      } as any,
+    );
+
+    expect(result.errors.recipient?.name).toBe("InvalidAddressBecauseDestinationIsAlsoSource");
+  });
+
+  it("errors if recipient is new and amount is too low", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    mockCachedRecipientIsNew.mockResolvedValue(true);
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 5_000_000n,
+        fee: 10_000n,
+        recipient: RECIPIENT_NEW,
+      } as any,
+    );
+
+    expect(result.errors.amount?.name).toBe("NotEnoughBalanceBecauseDestinationNotCreated");
+  });
+
+  it("errors if amount is zero", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 0n,
+        fee: 10_000n,
+        recipient: RECIPIENT,
+      } as any,
+    );
+
+    expect(result.errors.amount?.name).toBe("AmountRequired");
+  });
+
+  it("errors if recipient is invalid", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 1_000_000n,
+        fee: 10_000n,
+        recipient: "not-an-address",
+      } as any,
+    );
+
+    expect(result.errors.recipient?.name).toBe("InvalidAddress");
+  });
+
+  it("errors if recipient is missing", async () => {
+    mockGetServerInfos.mockResolvedValue({
+      info: {
+        validated_ledger: {
+          reserve_base_xrp: reserveBase / 1_000_000n,
+        },
+      },
+    });
+
+    const result = await getTransactionStatus(
+      account as any,
+      {
+        amount: 1_000_000n,
+        fee: 10_000n,
+        recipient: "",
+      } as any,
+    );
+
+    expect(result.errors.recipient?.name).toBe("RecipientRequired");
+  });
+});

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

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

package/src/logic/index.ts

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

package/src/logic/utils.ts

@@ -22,6 +22,15 @@ function isRecipientValid(recipient: string): boolean {
   return isValidClassicAddress(recipient);
 }
 
+// --- 10-Seconds Cache Implementation ---
+type CacheEntry = {
+  value: boolean;
+  expiresAt: number;
+};
+
+const recipientCache = new Map<string, CacheEntry>();
+const TTL = 10 * 1000; // 10 seconds
+
 const recipientIsNew = async (recipient: string): Promise<boolean> => {
   if (!isRecipientValid(recipient)) return false;
 
@@ -29,12 +38,19 @@ const recipientIsNew = async (recipient: string): Promise<boolean> => {
   return info.isNewAccount;
 };
 
-const cacheRecipientsNew: Record<string, boolean> = {};
-export const cachedRecipientIsNew = async (recipient: string) => {
-  if (recipient in cacheRecipientsNew) return cacheRecipientsNew[recipient];
-  cacheRecipientsNew[recipient] = await recipientIsNew(recipient);
-  return cacheRecipientsNew[recipient];
-};
-export const removeCachedRecipientIsNew = (recipient: string) => {
-  delete cacheRecipientsNew[recipient];
+export const cachedRecipientIsNew = async (recipient: string): Promise<boolean> => {
+  const now = Date.now();
+  const cached = recipientCache.get(recipient);
+
+  if (cached && now < cached.expiresAt) {
+    return cached.value;
+  }
+
+  const isNew = await recipientIsNew(recipient);
+  recipientCache.set(recipient, {
+    value: isNew,
+    expiresAt: now + TTL,
+  });
+
+  return isNew;
 };

package/src/test/bridgeDatasetTest.ts

@@ -1,7 +1,7 @@
 import BigNumber from "bignumber.js";
 import { DatasetTest } from "@ledgerhq/types-live";
 import { InvalidAddressBecauseDestinationIsAlsoSource } from "@ledgerhq/errors";
-import { fromTransactionRaw } from "../bridge/transaction";
+import { fromTransactionRaw } from "../transaction";
 import { Transaction } from "../types";
 
 export const newAddress1 = "rZvBc5e2YR1A9otS3r9DyGh3NDP8XLLp4";
@@ -97,18 +97,19 @@ export const dataset: DatasetTest<Transaction> = {
                 recipient: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
                 amount: "10000000",
                 tag: null,
-                fee: "1",
+                fee: "10", // NOTE: fee is not customizable, this field is ignored
                 feeCustomUnit: null,
                 networkInfo: null,
               }),
               expectedStatus: {
                 amount: new BigNumber("10000000"),
-                estimatedFees: new BigNumber("1"),
+                estimatedFees: new BigNumber("10"), // NOTE: hardcoded fee
+
                 errors: {
                   recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
                 },
                 warnings: {},
-                totalSpent: new BigNumber("10000001"),
+                totalSpent: new BigNumber("10000010"), // NOTE: amount + hardcoded fee
               },
             },
             {
@@ -118,16 +119,16 @@ export const dataset: DatasetTest<Transaction> = {
                 recipient: "rB6pwovsyrFWhPYUsjj9V3CHck985QjiXi",
                 amount: "10000000",
                 tag: 12345,
-                fee: "1",
+                fee: "10", // NOTE: fee is not customizable, this field is ignored
                 feeCustomUnit: null,
                 networkInfo: null,
               }),
               expectedStatus: {
                 amount: new BigNumber("10000000"),
-                estimatedFees: new BigNumber("1"),
+                estimatedFees: new BigNumber("10"), // NOTE: hardcoded fee
                 errors: {},
                 warnings: {},
-                totalSpent: new BigNumber("10000001"),
+                totalSpent: new BigNumber("10000010"), // NOTE: amount + hardcoded fee
               },
             },
           ],

package/src/{bridge/transaction.ts → 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/types/model.ts

@@ -1,3 +1,5 @@
+import { TypedMapMemo } from "@ledgerhq/coin-framework/api/types";
+
 export type AccountInfo = {
   isNewAccount: boolean;
   balance: string;
@@ -11,7 +13,16 @@ export type XrpMemo = {
   type?: string;
 };
 
+export type XrpMemoKind = "destinationTag" | "memo";
+
+export type XrpMemoValueMap = {
+  destinationTag: string;
+  memos: string[];
+};
+export type XrpMapMemo = TypedMapMemo<XrpMemoValueMap>;
+
 type Order = "asc" | "desc";
+
 export type ListOperationsOptions = {
   // pagination:
   limit?: number;

package/lib/bridge/broadcast.d.ts

@@ -1,4 +0,0 @@
-import { AccountBridge } from "@ledgerhq/types-live";
-import { Transaction } from "../types";
-export declare const broadcast: AccountBridge<Transaction>["broadcast"];
-//# sourceMappingURL=broadcast.d.ts.map

package/lib/bridge/broadcast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../src/bridge/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,WAAW,CAK7D,CAAC"}

package/lib/bridge/broadcast.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.broadcast = void 0;
-const operation_1 = require("@ledgerhq/coin-framework/operation");
-const logic_1 = require("../logic");
-const broadcast = async ({ signedOperation: { signature, operation }, }) => {
-    const hash = await (0, logic_1.broadcast)(signature);
-    return (0, operation_1.patchOperationWithHash)(operation, hash);
-};
-exports.broadcast = broadcast;
-//# sourceMappingURL=broadcast.js.map

package/lib/bridge/broadcast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.js","sourceRoot":"","sources":["../../src/bridge/broadcast.ts"],"names":[],"mappings":";;;AACA,kEAA4E;AAC5E,oCAAuD;AAGhD,MAAM,SAAS,GAA4C,KAAK,EAAE,EACvE,eAAe,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,GAC1C,EAAE,EAAE;IACH,MAAM,IAAI,GAAG,MAAM,IAAA,iBAAc,EAAC,SAAS,CAAC,CAAC;IAC7C,OAAO,IAAA,kCAAsB,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC,CAAC;AALW,QAAA,SAAS,aAKpB"}

package/lib/bridge/createTransaction.d.ts

@@ -1,4 +0,0 @@
-import { Transaction } from "../types";
-import { AccountBridge } from "@ledgerhq/types-live";
-export declare const createTransaction: AccountBridge<Transaction>["createTransaction"];
-//# sourceMappingURL=createTransaction.d.ts.map

package/lib/bridge/createTransaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTransaction.d.ts","sourceRoot":"","sources":["../../src/bridge/createTransaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,mBAAmB,CAQ5E,CAAC"}

package/lib/bridge/createTransaction.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTransaction = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const createTransaction = () => ({
-    family: "xrp",
-    amount: new bignumber_js_1.default(0),
-    recipient: "",
-    fee: null,
-    tag: undefined,
-    networkInfo: null,
-    feeCustomUnit: null,
-});
-exports.createTransaction = createTransaction;
-//# sourceMappingURL=createTransaction.js.map