@ledgerhq/coin-mina 1.1.0-nightly.0

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,175 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+} from "@ledgerhq/errors";
+import { AccountCreationFeeWarning, InvalidMemoMina, AmountTooSmall } from "./errors";
+import getTransactionStatus from "./getTransactionStatus";
+import { createMockAccount, createMockTransaction } from "../test/fixtures";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { Transaction } from "../types/common";
+import getEstimatedFees from "./getEstimatedFees";
+
+// Mock dependencies
+jest.mock("@ledgerhq/coin-framework/currencies", () => ({
+  formatCurrencyUnit: jest.fn().mockReturnValue("0.1 MINA"),
+}));
+jest.mock("./getEstimatedFees");
+
+describe("getTransactionStatus", () => {
+  // Standard test fixtures
+  const mockAccount = createMockAccount();
+  const mockTransaction = createMockTransaction({ amount: new BigNumber(800) });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return a valid transaction status with no errors for valid inputs", async () => {
+    const result = await getTransactionStatus(mockAccount, mockTransaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.estimatedFees).toEqual(new BigNumber(10));
+    expect(result.amount).toEqual(new BigNumber(800));
+    expect(result.totalSpent).toEqual(new BigNumber(810)); // amount + fee
+  });
+
+  it("should handle missing fees with FeeNotLoaded error", async () => {
+    (getEstimatedFees as jest.Mock).mockResolvedValue({
+      fee: new BigNumber(10),
+      accountCreationFee: new BigNumber(0),
+    });
+    // Using Type casting to handle the null fees for testing purposes
+    const txWithoutFees: Transaction = {
+      ...mockTransaction,
+      fees: {
+        fee: new BigNumber(0),
+        accountCreationFee: new BigNumber(0),
+      },
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithoutFees);
+
+    expect(result.errors.fees).toBeInstanceOf(FeeNotLoaded);
+  });
+
+  it("should handle missing recipient with RecipientRequired error", async () => {
+    const txWithoutRecipient = {
+      ...mockTransaction,
+      recipient: "",
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithoutRecipient);
+
+    expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
+  });
+
+  it("should handle invalid recipient address with InvalidAddress error", async () => {
+    const txWithInvalidRecipient = {
+      ...mockTransaction,
+      recipient: "invalid-address",
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithInvalidRecipient);
+
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddress);
+  });
+
+  it("should handle self-transfer with InvalidAddressBecauseDestinationIsAlsoSource error", async () => {
+    const txWithSelfTransfer = {
+      ...mockTransaction,
+      recipient: mockAccount.freshAddress,
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithSelfTransfer);
+
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+  });
+
+  it("should handle invalid memo with InvalidMemoMina error", async () => {
+    const veryLongMemo = "a".repeat(33); // Create memo longer than MAX_MEMO_LENGTH (32)
+    const txWithInvalidMemo = {
+      ...mockTransaction,
+      memo: veryLongMemo,
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithInvalidMemo);
+
+    expect(result.errors.transaction).toBeInstanceOf(InvalidMemoMina);
+  });
+
+  it("should add AccountCreationFeeWarning when account creation fee is present", async () => {
+    const txWithAccountCreationFee = {
+      ...mockTransaction,
+      fees: {
+        fee: new BigNumber(10),
+        accountCreationFee: new BigNumber(100),
+      },
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithAccountCreationFee);
+
+    expect(result.warnings.recipient).toBeInstanceOf(AccountCreationFeeWarning);
+    expect(formatCurrencyUnit).toHaveBeenCalled();
+  });
+
+  it("should add AmountTooSmall error when amount is less than account creation fee", async () => {
+    const txWithSmallAmount = {
+      ...mockTransaction,
+      amount: new BigNumber(50),
+      fees: {
+        fee: new BigNumber(10),
+        accountCreationFee: new BigNumber(100),
+      },
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithSmallAmount);
+
+    expect(result.errors.amount).toBeInstanceOf(AmountTooSmall);
+  });
+
+  it("should handle zero amount with AmountRequired error when useAllAmount is false", async () => {
+    const txWithZeroAmount = {
+      ...mockTransaction,
+      amount: new BigNumber(0),
+      useAllAmount: false,
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithZeroAmount);
+
+    expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+
+  it("should handle amount greater than max with NotEnoughBalance error", async () => {
+    // Account has spendable balance of 900
+    const txWithTooLargeAmount = {
+      ...mockTransaction,
+      amount: new BigNumber(1000),
+      useAllAmount: false,
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithTooLargeAmount);
+
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should calculate correct amount and totalSpent when useAllAmount is true", async () => {
+    const txWithUseAllAmount = {
+      ...mockTransaction,
+      amount: new BigNumber(0), // Amount should be ignored when useAllAmount is true
+      useAllAmount: true,
+    };
+
+    const result = await getTransactionStatus(mockAccount, txWithUseAllAmount);
+
+    // Should return spendableBalance - fee as the amount
+    expect(result.amount).toEqual(new BigNumber(890)); // spendableBalance(900) - fee(10)
+    expect(result.totalSpent).toEqual(new BigNumber(900)); // spendableBalance
+    expect(result.errors).toEqual({});
+  });
+});

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,87 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+} from "@ledgerhq/errors";
+import type { Transaction, MinaAccount, TransactionStatus, StatusErrorMap } from "../types/common";
+import { isValidAddress, isValidMemo, getMaxAmount, getTotalSpent } from "../common-logic";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { AccountCreationFeeWarning, InvalidMemoMina, AmountTooSmall } from "./errors";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+
+const getTransactionStatus: AccountBridge<
+  Transaction,
+  MinaAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (a: MinaAccount, t: Transaction): Promise<TransactionStatus> => {
+  const errors: StatusErrorMap = {};
+  const warnings: StatusErrorMap = {};
+  const useAllAmount = !!t.useAllAmount;
+
+  if (t.fees.fee.lte(0)) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (!t.recipient) {
+    errors.recipient = new RecipientRequired();
+  }
+
+  if (t.recipient && !isValidAddress(t.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  }
+
+  if (t.memo && !isValidMemo(t.memo)) {
+    errors.transaction = new InvalidMemoMina();
+  }
+
+  if (t.recipient === a.freshAddress) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (t.fees?.accountCreationFee.gt(0)) {
+    const fee = formatCurrencyUnit(a.currency.units[0], t.fees.accountCreationFee, {
+      showCode: true,
+      disableRounding: true,
+    });
+    warnings.recipient = new AccountCreationFeeWarning(undefined, {
+      fee,
+    });
+
+    if (t.amount.lt(t.fees.accountCreationFee) && t.amount.gt(0)) {
+      errors.amount = new AmountTooSmall(undefined, {
+        amount: fee,
+      });
+    }
+  }
+
+  const estimatedFees = t.fees.fee || new BigNumber(0);
+
+  const maxAmountWithFees = getMaxAmount(a, t, estimatedFees);
+
+  const totalSpent = getTotalSpent(a, t, estimatedFees);
+  const amount = useAllAmount ? maxAmountWithFees : new BigNumber(t.amount);
+
+  if (amount.lte(0) && !t.useAllAmount) {
+    errors.amount = new AmountRequired();
+  }
+
+  if (amount.gt(maxAmountWithFees)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+};
+
+export default getTransactionStatus;

package/src/bridge/index.test.ts

@@ -0,0 +1,39 @@
+import { SignerContext } from "@ledgerhq/coin-framework/lib/signer";
+import { createBridges } from ".";
+import { MinaSigner } from "../types";
+import { MinaCoinConfig } from "../config";
+
+describe("createBridges", () => {
+  let bridges: ReturnType<typeof createBridges>;
+  beforeEach(() => {
+    bridges = createBridges(
+      undefined as unknown as SignerContext<MinaSigner>,
+      {} as unknown as MinaCoinConfig,
+    );
+  });
+
+  it("should return both bridges interface", () => {
+    expect(bridges.accountBridge).toBeDefined();
+    expect(bridges.currencyBridge).toBeDefined();
+  });
+
+  it("should have a currency bridge with required methods", () => {
+    expect(bridges.currencyBridge).toBeDefined();
+    expect(bridges.currencyBridge.preload).toBeDefined();
+    expect(bridges.currencyBridge.hydrate).toBeDefined();
+    expect(bridges.currencyBridge.scanAccounts).toBeDefined();
+  });
+
+  it("should have an account bridge with required methods", () => {
+    expect(bridges.accountBridge).toBeDefined();
+    expect(bridges.accountBridge.broadcast).toBeDefined();
+    expect(bridges.accountBridge.createTransaction).toBeDefined();
+    expect(bridges.accountBridge.estimateMaxSpendable).toBeDefined();
+    expect(bridges.accountBridge.getTransactionStatus).toBeDefined();
+    expect(bridges.accountBridge.prepareTransaction).toBeDefined();
+    expect(bridges.accountBridge.receive).toBeDefined();
+    expect(bridges.accountBridge.signOperation).toBeDefined();
+    expect(bridges.accountBridge.sync).toBeDefined();
+    expect(bridges.accountBridge.updateTransaction).toBeDefined();
+  });
+});

package/src/bridge/index.ts

@@ -0,0 +1,72 @@
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import {
+  makeAccountBridgeReceive,
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { Transaction } from "../types/common";
+import resolver from "../signer/getAddress";
+import { sync, getAccountShape } from "./synchronisation";
+import { MinaSigner } from "../types/signer";
+import { MinaCoinConfig, setCoinConfig } from "../config";
+import broadcast from "./broadcast";
+import { createTransaction } from "./createTransaction";
+import estimateMaxSpendable from "./estimateMaxSpendable";
+import getTransactionStatus from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import buildSignOperation from "./signOperation";
+import makeCliTools from "./cli-transaction";
+
+export { makeCliTools };
+
+export function buildCurrencyBridge(signerContext: SignerContext<MinaSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    preload: async () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<MinaSigner>,
+): AccountBridge<Transaction> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    getSerializedAddressParameters,
+  };
+}
+
+export function createBridges(
+  signerContext: SignerContext<MinaSigner>,
+  coinConfig: MinaCoinConfig,
+) {
+  setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,43 @@
+import BigNumber from "bignumber.js";
+import estimateFees from "./getEstimatedFees";
+import { getNonce } from "../api";
+import { prepareTransaction } from "./prepareTransaction";
+import { Account } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+jest.mock("../api");
+jest.mock("./getEstimatedFees");
+
+describe("prepareTransaction", () => {
+  let estimateFeesSpy: jest.SpyInstance;
+  let getNonceSpy: jest.SpyInstance;
+  beforeEach(() => {
+    getNonceSpy = jest.spyOn({ getNonce }, "getNonce");
+    estimateFeesSpy = jest.spyOn({ estimateFees }, "estimateFees");
+    estimateFeesSpy.mockResolvedValue({
+      fee: new BigNumber(1),
+      accountCreationFee: new BigNumber(1),
+    });
+    getNonceSpy.mockResolvedValue(1);
+  });
+
+  it("should update fee fields if it's different", async () => {
+    const oldTx = {
+      fees: { fee: new BigNumber(0), accountCreationFee: new BigNumber(0) },
+    };
+    const newTx = await prepareTransaction({} as Account, oldTx as Transaction);
+    expect(newTx.fees.fee).toEqual(new BigNumber(1));
+    expect(newTx.fees.accountCreationFee).toEqual(new BigNumber(1));
+    expect(getNonceSpy).toHaveBeenCalledTimes(1);
+    expect(getNonceSpy).toHaveBeenCalledWith(oldTx, undefined);
+  });
+
+  it("should update nonce if it's different", async () => {
+    const oldTx = {
+      nonce: 0,
+      fees: { fee: new BigNumber(0), accountCreationFee: new BigNumber(0) },
+    };
+    const newTx = await prepareTransaction({} as Account, oldTx as Transaction);
+    expect(newTx.nonce).toEqual(1);
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,24 @@
+import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import estimateMaxSpendable from "./estimateMaxSpendable";
+import getEstimatedFees from "./getEstimatedFees";
+import { MinaAccount, Transaction } from "../types/common";
+import { getNonce } from "../api";
+
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  MinaAccount
+>["prepareTransaction"] = async (a: Account, t: Transaction) => {
+  const { fee, accountCreationFee } = await getEstimatedFees(t, a.freshAddress);
+
+  const amount = t.useAllAmount
+    ? await estimateMaxSpendable({
+        account: a,
+        transaction: t,
+      })
+    : t.amount;
+
+  const nonce = await getNonce(t, a.freshAddress);
+
+  return updateTransaction(t, { fees: { fee, accountCreationFee }, amount, nonce });
+};

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,158 @@
+import { BigNumber } from "bignumber.js";
+import { firstValueFrom } from "rxjs";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { buildSignOperation, buildOptimisticOperation } from "./signOperation";
+import { buildTransaction } from "./buildTransaction";
+import { reEncodeRawSignature } from "../common-logic";
+import {
+  createMockAccount,
+  createMockTransaction,
+  createMockUnsignedTransaction,
+  mockDeviceId,
+  createMockSignerContext,
+} from "../test/fixtures";
+
+// Mock dependencies
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("./buildTransaction");
+jest.mock("../common-logic");
+
+describe("signOperation", () => {
+  // Mock reset before each test
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Setup mocks
+    (encodeOperationId as jest.Mock).mockReturnValue("mock_operation_id");
+    (buildTransaction as jest.Mock).mockResolvedValue(mockUnsignedTransaction);
+    (reEncodeRawSignature as jest.Mock).mockReturnValue("encoded_signature");
+  });
+
+  // Use fixtures instead of defining mock data locally
+  const mockAccount = createMockAccount();
+  const mockTransaction = createMockTransaction();
+  const mockUnsignedTransaction = createMockUnsignedTransaction(mockAccount, mockTransaction);
+  const mockSignerContext = createMockSignerContext();
+
+  describe("buildOptimisticOperation", () => {
+    it("should build operation with correct values", () => {
+      const result = buildOptimisticOperation(mockAccount, mockTransaction, new BigNumber(10));
+
+      expect(result).toEqual({
+        id: "mock_operation_id",
+        hash: "",
+        type: "OUT",
+        value: new BigNumber(1010), // amount + fee
+        fee: new BigNumber(10),
+        blockHash: null,
+        blockHeight: null,
+        senders: [mockAccount.freshAddress],
+        recipients: [mockTransaction.recipient],
+        accountId: mockAccount.id,
+        date: expect.any(Date),
+        extra: {
+          memo: "test memo",
+          accountCreationFee: "0",
+        },
+      });
+
+      expect(encodeOperationId).toHaveBeenCalledWith(mockAccount.id, "", "OUT");
+    });
+
+    it("should subtract account creation fee from value when present", () => {
+      const txWithCreationFee = createMockTransaction({
+        fees: {
+          fee: new BigNumber(10),
+          accountCreationFee: new BigNumber(5),
+        },
+      });
+
+      const result = buildOptimisticOperation(mockAccount, txWithCreationFee, new BigNumber(10));
+
+      // Value should be amount + fee - accountCreationFee = 1000 + 10 - 5 = 1005
+      expect(result.value).toEqual(new BigNumber(1005));
+      expect(result.extra.accountCreationFee).toBe("5");
+    });
+  });
+
+  describe("buildSignOperation", () => {
+    it("should emit correct events and return signed operation", done => {
+      const signOperation = buildSignOperation(mockSignerContext);
+
+      const events: string[] = [];
+      const observable = signOperation({
+        account: mockAccount,
+        transaction: mockTransaction,
+        deviceId: mockDeviceId,
+      });
+
+      observable.subscribe({
+        next: event => {
+          events.push(event.type);
+
+          if (event.type === "signed") {
+            const { operation, signature } = event.signedOperation;
+
+            // Check operation
+            expect(operation).toEqual(
+              expect.objectContaining({
+                id: "mock_operation_id",
+                type: "OUT",
+                value: new BigNumber(1010),
+                fee: new BigNumber(10),
+                senders: [mockAccount.freshAddress],
+                recipients: [mockTransaction.recipient],
+              }),
+            );
+
+            // Check signature
+            const parsedSignature = JSON.parse(signature);
+            expect(parsedSignature).toEqual({
+              transaction: mockUnsignedTransaction,
+              signature: "encoded_signature",
+            });
+          }
+        },
+        complete: () => {
+          // Check all events were emitted in the correct order
+          expect(events).toEqual([
+            "device-signature-requested",
+            "device-signature-granted",
+            "signed",
+          ]);
+          done();
+        },
+        error: error => done(error),
+      });
+    });
+
+    it("should build transaction with correct parameters", async () => {
+      const signOperation = buildSignOperation(mockSignerContext);
+
+      const observable = signOperation({
+        account: mockAccount,
+        transaction: mockTransaction,
+        deviceId: mockDeviceId,
+      });
+
+      await firstValueFrom(observable.pipe());
+
+      expect(buildTransaction).toHaveBeenCalledWith(mockAccount, mockTransaction);
+    });
+
+    it("should call signer with correct parameters", async () => {
+      const mockSignerContextSpy = createMockSignerContext();
+
+      const signOperation = buildSignOperation(mockSignerContextSpy);
+
+      const observable = signOperation({
+        account: mockAccount,
+        transaction: mockTransaction,
+        deviceId: mockDeviceId,
+      });
+
+      await firstValueFrom(observable.pipe());
+
+      expect(mockSignerContextSpy).toHaveBeenCalledWith(mockDeviceId, expect.any(Function));
+    });
+  });
+});