@ledgerhq/coin-mina 1.1.0-next.0

package/src/common-logic/index.test.ts

@@ -0,0 +1,225 @@
+import {
+  getAccountNumFromPath,
+  isValidAddress,
+  getMaxAmount,
+  getTotalSpent,
+  reEncodeRawSignature,
+  isValidMemo,
+} from ".";
+import { BigNumber } from "bignumber.js";
+import type { MinaAccount, Transaction } from "../types/common";
+import { MAX_MEMO_LENGTH } from "../consts";
+import { Operation } from "@ledgerhq/types-live";
+
+// Create a minimal mock implementation for the tests
+type MockMinaAccount = Pick<MinaAccount, "spendableBalance" | "pendingOperations">;
+type MockTransaction = Partial<Transaction>;
+
+// Mock functions to create test objects
+function createMockAccount(overrides: Partial<MockMinaAccount> = {}): MockMinaAccount {
+  return {
+    spendableBalance: new BigNumber(1000),
+    pendingOperations: [],
+    ...overrides,
+  };
+}
+
+function createMockTransaction(overrides: Partial<MockTransaction> = {}): MockTransaction {
+  return {
+    family: "mina",
+    amount: new BigNumber(0),
+    recipient: "B62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc",
+    ...overrides,
+  };
+}
+
+describe("getAccountNumFromPath", () => {
+  it("should return undefined for invalid account number", () => {
+    const account = getAccountNumFromPath("44'/616'/4'/0/0");
+    expect(account).toBe(undefined);
+  });
+
+  it("should return undefined for unsupported path", () => {
+    const account = getAccountNumFromPath("44'/616'/4/0/0");
+    expect(account).toBe(undefined);
+  });
+
+  it("should return the account number", () => {
+    const account = getAccountNumFromPath("44'/12586'/4'/0/0");
+    expect(account).toBe(4);
+  });
+});
+
+describe("testingAddress", () => {
+  const validAddresses = [
+    "B62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc",
+    "B62qr5cXFjdnZXYxP5dEwRY7wENxcod4Q2oLxUDiq1QrBXZZyxMH8q4",
+    "B62qqmRToRiXZjyLLMJoGnQFXXZuZWdqaNYr43xEDDQzkXMHLouCMZp",
+    "B62qnixP59E4vJytpDWZ5YQPrnmqb7YNwhVWiuSAkxbYdX5RauHWwcm",
+    "B62qmfBiJx88gM9opov4MDxmDVKMutQsBQ1aGt7TrQYyGQx66fRFxvC",
+    "B62qosg21UpwpfPFaxTyirdfUVDHe2Ynsyv1QydE4z34zbLuBZ92ALM",
+    "B62qkWUvsVEnXmd4poHbkKujHNnjxkDcZtrLxN1FTa8pp3GkfHMB1gv",
+    "B62qoiK7DJurVUUJx1dmJGULdNUmX5bjdiYvoWXEXGugS2Cx3YDsHhy",
+    "B62qn1KptFUxxu8aRS52NGQ3GWzn5h8v7U9k571r4LCs5obpoZyd81e",
+    "B62qis2tX1rveddCeJeBAZJnXcCwWPp1x9ScZ3iMCxbV29gRbxWo7qi",
+    "B62qpBKEDTnS4efjBmou7iztx5x152JEmc29XMR1Y3FVCpnmfKGX4R4",
+    "B62qro5bGnk7eCNMA1S5QWmzn5sCcRWckbw83GGaqN3HM2QzP9zYS83",
+    "B62qospDjUj43x2yMKiNehojWWRUsE1wpdUDVpfxH8V3n5Y1QgJKFfw",
+    "B62qrmYwToypQv8v9cjxJdyhAxKihrqtTtEkYC4Y3u412KCPLGSD93V",
+    "B62qj3rpYkGM1T3VN6JDAJs9NccHCRQDYMcQ6UCBc81ff5HXTDjU44d",
+    "B62qp2kks3r14P8GWkR2ieT18JobwnmrBFGEoqy3dAReiyM8aDp4be7",
+    "B62qpW1SYPcp7TcHJYL6egnN9qzvNtQL5XGyiM8S6UsHvxCYzhhFPjz",
+    "B62qospDjUj43x2yMKiNehojWWRUsE1wpdUDVpfxH8V3n5Y1QgJKFfw",
+    "B62qj5L8U8A8gexpHLWHxBdfjKuWb8HMguVPecQ5FGqgZAwBAKHvhEy",
+    "B62qnt5WShcbVVnVqQqWjkyMJdxMwLq4QbRbgMjoi5nmvQw7dZLRtpx",
+    "B62qrGUxqRWn9A8PEJschgLZuS5S1GJiairh65mgTapaK58nkTKHUs8",
+    "B62qkS7hmMkzmNDjeCUKyAMZSw1c98MxszZPA7WnvBuh7Pq66ztiwdt",
+    "B62qjGWerE9MPNk7E2jEJe9Ex5GxkNR9JCc5mhFeJdGFaNDHnMdGQJQ",
+    "B62qpp2DLkLxwFn1QZdkEWgiRFMYnkgh6cj5AJC5pqCYiALh8BmiYJ8",
+    "B62qqALaAoEnaJPSNmQaDkUwFGiKwZo4zRK4Ay5eSMxAMVhNxwr2KeM",
+    "B62qospDjUj43x2yMKiNehojWWRUsE1wpdUDVpfxH8V3n5Y1QgJKFfw",
+    "B62qr3epzHUrxrdminUN4Hzuinuc7aBDAFSR94mPmmxVsbuFpUvDDq6",
+    "B62qrJurUKtcqdhQu1XtJJfSH7rR1xrEtSWPQQcFwBJBwVcsFSyVSM3",
+  ];
+
+  const invalidAddresses = [
+    "", // Empty address
+    null, // Null address
+    undefined, // Undefined address
+    "123", // Too short
+    "B61qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc", // Incorrect prefix
+    "B62q!@#$%^&*()_+{}|:<>?`~", // Invalid characters
+    "B62qj5L8U8A8gexpHLWHxBdfjKuWb8HMguVPecQ5FGqgZAwBAKHvhE", // Too short
+    "B62qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq", // Too long
+    " B62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc", // Leading whitespace
+    "B62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc ", // Trailing whitespace
+    "B62qiVhtBtqakq8sNTHdC TXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc", // Internal whitespace
+    "C62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc", // Incorrect prefix
+  ];
+
+  it("should return true for valid address", () => {
+    for (const address of validAddresses) {
+      expect(isValidAddress(address)).toBe(true);
+    }
+  });
+
+  it("should return false for invalid address", () => {
+    for (const address of invalidAddresses) {
+      expect(isValidAddress(address as string)).toBe(false);
+    }
+  });
+});
+
+describe("isValidMemo", () => {
+  it("should return true for valid memo", () => {
+    expect(isValidMemo("")).toBe(true);
+    expect(isValidMemo("Valid memo")).toBe(true);
+    expect(isValidMemo("A".repeat(MAX_MEMO_LENGTH))).toBe(true);
+  });
+
+  it("should return false for memo exceeding max length", () => {
+    expect(isValidMemo("A".repeat(MAX_MEMO_LENGTH + 1))).toBe(false);
+  });
+});
+
+describe("getMaxAmount", () => {
+  it("should calculate correct max amount with no fees", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(1000),
+      pendingOperations: [],
+    });
+    const transaction = createMockTransaction();
+
+    expect(getMaxAmount(account as MinaAccount, transaction as Transaction).toNumber()).toBe(1000);
+  });
+
+  it("should calculate correct max amount with fees", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(1000),
+      pendingOperations: [],
+    });
+    const transaction = createMockTransaction();
+    const fees = new BigNumber(10);
+
+    expect(getMaxAmount(account as MinaAccount, transaction as Transaction, fees).toNumber()).toBe(
+      990,
+    );
+  });
+
+  it("should subtract pending operations from max amount", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(1000),
+      pendingOperations: [
+        { value: new BigNumber(100) } as Operation,
+        { value: new BigNumber(200) } as Operation,
+      ],
+    });
+    const transaction = createMockTransaction();
+
+    expect(getMaxAmount(account as MinaAccount, transaction as Transaction).toNumber()).toBe(700);
+  });
+
+  it("should return 0 when max amount would be negative", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(100),
+      pendingOperations: [{ value: new BigNumber(200) } as Operation],
+    });
+    const transaction = createMockTransaction();
+
+    expect(getMaxAmount(account as MinaAccount, transaction as Transaction).toNumber()).toBe(0);
+  });
+});
+
+describe("getTotalSpent", () => {
+  it("should return spendable balance when useAllAmount is true", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(1000),
+    });
+    const transaction = createMockTransaction({
+      useAllAmount: true,
+      amount: new BigNumber(500),
+    });
+    const fees = new BigNumber(10);
+
+    expect(getTotalSpent(account as MinaAccount, transaction as Transaction, fees).toNumber()).toBe(
+      1000,
+    );
+  });
+
+  it("should return amount plus fees when useAllAmount is false", () => {
+    const account = createMockAccount({
+      spendableBalance: new BigNumber(1000),
+    });
+    const transaction = createMockTransaction({
+      useAllAmount: false,
+      amount: new BigNumber(500),
+    });
+    const fees = new BigNumber(10);
+
+    expect(getTotalSpent(account as MinaAccount, transaction as Transaction, fees).toNumber()).toBe(
+      510,
+    );
+  });
+});
+
+describe("reEncodeRawSignature", () => {
+  it("should correctly re-encode a valid signature", () => {
+    const rawSignature = "a".repeat(64) + "b".repeat(64);
+    const result = reEncodeRawSignature(rawSignature);
+
+    // Check that the result has the correct format (reverse bytes)
+    expect(result.length).toBe(128);
+
+    // Check field part
+    const fieldPart = result.substring(0, 64);
+    expect(fieldPart).toBe("a".repeat(64).match(/.{2}/g)?.reverse().join(""));
+
+    // Check scalar part
+    const scalarPart = result.substring(64);
+    expect(scalarPart).toBe("b".repeat(64).match(/.{2}/g)?.reverse().join(""));
+  });
+
+  it("should throw an error for invalid signature length", () => {
+    expect(() => reEncodeRawSignature("too_short")).toThrow("Invalid raw signature input");
+  });
+});

package/src/common-logic/index.ts

@@ -0,0 +1,97 @@
+import { BigNumber } from "bignumber.js";
+import { Transaction, MinaAccount } from "../types/common";
+import { CoinType } from "@ledgerhq/types-cryptoassets";
+import { MAX_MEMO_LENGTH, MINA_DECODED_ADDRESS_LENGTH } from "../consts";
+import bs58check from "bs58check";
+
+/*
+ * Validate a Mina address.
+ */
+export function isValidAddress(address: string) {
+  try {
+    if (!address.toLowerCase().startsWith("b62")) {
+      return false;
+    }
+    const decodedAddress = Buffer.from(bs58check.decode(address)).toString("hex");
+    return !!decodedAddress && decodedAddress.length === MINA_DECODED_ADDRESS_LENGTH;
+  } catch (ex) {
+    return false;
+  }
+}
+
+export const isValidMemo = (memo: string): boolean => {
+  return memo.length <= MAX_MEMO_LENGTH;
+};
+
+// Get the account number from the path
+export const getAccountNumFromPath = (path: string): number | undefined => {
+  const parts = path.split("'/");
+
+  if (parts.length === 3) {
+    return;
+  }
+
+  if (parts[1] !== `${CoinType.MINA}`) {
+    return;
+  }
+
+  try {
+    const acc = parseInt(parts[2], 10);
+    if (acc >= 0) {
+      return acc;
+    }
+    return;
+  } catch (e) {
+    return;
+  }
+};
+
+/*
+ * Get the max amount that can be spent, taking into account tx type and pending operations.
+ */
+export const getMaxAmount = (a: MinaAccount, _t: Transaction, fees?: BigNumber): BigNumber => {
+  let maxAmount;
+
+  let pendingDefaultAmount = new BigNumber(0);
+
+  a.pendingOperations.forEach(({ value }) => {
+    pendingDefaultAmount = pendingDefaultAmount.plus(value);
+  });
+
+  maxAmount = a.spendableBalance.minus(pendingDefaultAmount);
+  if (fees) {
+    maxAmount = maxAmount.minus(fees);
+  }
+  if (maxAmount === undefined || maxAmount.lt(0)) {
+    return new BigNumber(0);
+  }
+
+  return maxAmount;
+};
+
+export const getTotalSpent = (a: MinaAccount, t: Transaction, fees: BigNumber): BigNumber => {
+  if (t.useAllAmount) {
+    return a.spendableBalance;
+  }
+
+  return new BigNumber(t.amount).plus(fees);
+};
+
+// reEncodeRawSignature takes a raw signature in the form of a 128-character hex string and returns a re-encoded version of it.
+export function reEncodeRawSignature(rawSignature: string) {
+  function shuffleBytes(hex: string) {
+    const bytes = hex.match(/.{2}/g);
+    if (!bytes) {
+      throw "Invalid hex input";
+    }
+    bytes.reverse();
+    return bytes.join("");
+  }
+
+  if (rawSignature.length !== 128) {
+    throw "Invalid raw signature input";
+  }
+  const field = rawSignature.substring(0, 64);
+  const scalar = rawSignature.substring(64);
+  return shuffleBytes(field) + shuffleBytes(scalar);
+}

package/src/config.ts

@@ -0,0 +1,21 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type MinaCoinConfig = () => CurrencyConfig & {
+  infra: {
+    API_MINA_ROSETTA_NODE: string;
+  };
+};
+
+let coinConfig: MinaCoinConfig | undefined;
+
+export const setCoinConfig = (config: MinaCoinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): ReturnType<MinaCoinConfig> => {
+  if (!coinConfig?.()) {
+    throw new Error("Mina module config not set");
+  }
+
+  return coinConfig();
+};

package/src/consts.ts

@@ -0,0 +1,18 @@
+export const MAINNET_NETWORK_IDENTIFIER = {
+  network_identifier: {
+    blockchain: "mina",
+    network: "mainnet",
+  },
+};
+
+export const MINA_MAINNET_NETWORK_ID = 1;
+export const MINA_PAYMENT_TYPE_ID = 0;
+export const MINA_TOKEN_ID = "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf";
+export const MINA_DECIMALS = 9;
+export const MINA_SYMBOL = "MINA";
+export const MINA_CURVE_TYPE = "pallas";
+
+export const MAX_MEMO_LENGTH = 32;
+export const MINA_DECODED_ADDRESS_LENGTH = 72;
+
+export const MAX_TRANSACTIONS_PER_PAGE = 100;

package/src/signer/getAddress.test.ts

@@ -0,0 +1,131 @@
+import resolver from "./getAddress";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { MinaSigner } from "../types/signer";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/lib/currencies";
+import { DerivationMode } from "@ledgerhq/types-live";
+
+describe("Mina getAddress resolver", () => {
+  // Mock the signer context
+  const mockSigner: MinaSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  };
+  const commonOptions = {
+    currency: getCryptoCurrencyById("mina"),
+    derivationMode: "minabip44" as DerivationMode,
+  };
+
+  const mockSignerContext: SignerContext<MinaSigner> = jest.fn(async (deviceId, callback) => {
+    return callback(mockSigner);
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the signer with the correct account number", async () => {
+    const options: GetAddressOptions = {
+      ...commonOptions,
+      path: "44'/12586'/0'/0/0",
+      verify: false,
+    };
+
+    // Mock response from signer
+    (mockSigner.getAddress as jest.Mock).mockResolvedValue({
+      publicKey: "testPublicKey123",
+    });
+
+    const getAddress = resolver(mockSignerContext);
+    await getAddress("device1", options);
+
+    expect(mockSigner.getAddress).toHaveBeenCalledWith(0, false);
+  });
+
+  it("should pass the verify flag correctly", async () => {
+    const options: GetAddressOptions = {
+      path: "44'/12586'/2'/0/0",
+      verify: true,
+      ...commonOptions,
+    };
+
+    // Mock response from signer
+    (mockSigner.getAddress as jest.Mock).mockResolvedValue({
+      publicKey: "testPublicKey456",
+    });
+
+    const getAddress = resolver(mockSignerContext);
+    await getAddress("device1", options);
+
+    expect(mockSigner.getAddress).toHaveBeenCalledWith(2, true);
+  });
+
+  it("should default to verify=false when not provided", async () => {
+    const options: GetAddressOptions = {
+      path: "44'/12586'/1'/0/0",
+      ...commonOptions,
+    };
+
+    // Mock response from signer
+    (mockSigner.getAddress as jest.Mock).mockResolvedValue({
+      publicKey: "testPublicKey789",
+    });
+
+    const getAddress = resolver(mockSignerContext);
+    await getAddress("device1", options);
+
+    expect(mockSigner.getAddress).toHaveBeenCalledWith(1, false);
+  });
+
+  it("should return the correct address format", async () => {
+    const options: GetAddressOptions = {
+      path: "44'/12586'/3'/0/0",
+      ...commonOptions,
+    };
+
+    const expectedPublicKey = "minaPublicKeyABC123";
+
+    // Mock response from signer
+    (mockSigner.getAddress as jest.Mock).mockResolvedValue({
+      publicKey: expectedPublicKey,
+    });
+
+    const getAddress = resolver(mockSignerContext);
+    const result = await getAddress("device1", options);
+
+    expect(result).toEqual({
+      address: expectedPublicKey,
+      publicKey: expectedPublicKey,
+      path: options.path,
+    });
+  });
+
+  it("should throw an error for invalid path", async () => {
+    const options: GetAddressOptions = {
+      path: "44'/789'/0'/0/0", // Invalid coin type for Mina
+      verify: false,
+      ...commonOptions,
+    };
+
+    const getAddress = resolver(mockSignerContext);
+    await expect(getAddress("device1", options)).rejects.toThrow();
+  });
+
+  it("should throw an error when publicKey is undefined", async () => {
+    const options: GetAddressOptions = {
+      path: "44'/12586'/0'/0/0",
+      verify: false,
+      ...commonOptions,
+    };
+
+    // Mock response from signer with undefined publicKey
+    (mockSigner.getAddress as jest.Mock).mockResolvedValue({
+      publicKey: undefined,
+    });
+
+    const getAddress = resolver(mockSignerContext);
+    await expect(getAddress("device1", options)).rejects.toThrow(
+      "[mina] getAddress: expected publicKey to be defined",
+    );
+  });
+});

package/src/signer/getAddress.ts

@@ -0,0 +1,24 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { GetAddressResponse, MinaSigner } from "../types/signer";
+import { getAccountNumFromPath } from "../common-logic";
+import invariant from "invariant";
+
+const resolver = (signerContext: SignerContext<MinaSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const account = getAccountNumFromPath(path);
+    invariant(account !== undefined, "Invalid account path, supported: 44'/12586'/<account>'/0/0");
+    const r = (await signerContext(deviceId, signer =>
+      signer.getAddress(account, verify || false),
+    )) as GetAddressResponse;
+    invariant(r.publicKey, "[mina] getAddress: expected publicKey to be defined");
+    return {
+      address: r.publicKey,
+      publicKey: r.publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,3 @@
+import resolver from "./getAddress";
+
+export default resolver;

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,73 @@
+import type { DeviceAction, State } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types/common";
+import { deviceActionFlow, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/lib/currencies/formatCurrencyUnit";
+
+export const acceptTransaction: DeviceAction<Transaction, State<Transaction>> = deviceActionFlow({
+  steps: [
+    {
+      title: "Sign",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Type",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "Payment",
+    },
+    {
+      title: "Sender",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Receiver",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) =>
+        `MINA ${formatCurrencyUnit(account.currency.units[0], transaction.amount, {
+          dynamicSignificantDigits: 11,
+          staticSignificantDigits: 11,
+        })}`,
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) =>
+        `MINA ${formatCurrencyUnit(account.currency.units[0], transaction.fees.fee, {
+          dynamicSignificantDigits: 11,
+          staticSignificantDigits: 11,
+        })}`,
+    },
+    {
+      title: "Total",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) =>
+        `MINA ${formatCurrencyUnit(
+          account.currency.units[0],
+          transaction.fees.fee.plus(transaction.amount),
+          {
+            dynamicSignificantDigits: 11,
+            staticSignificantDigits: 11,
+          },
+        )}`,
+    },
+    {
+      title: "Memo",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.memo ?? "",
+    },
+    {
+      title: "Nonce",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.nonce.toString(),
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});