@ledgerhq/coin-mina 1.1.0-next.0

package/src/api/rosetta/types.ts

@@ -0,0 +1,156 @@
+export type FetchNetworkStatusResponse = {
+  current_block_identifier: {
+    index: number;
+    hash: string;
+  };
+  current_block_timestamp: number;
+  genesis_block_identifier: {
+    index: number;
+    hash: string;
+  };
+  oldest_block_identifier: {
+    index: number;
+    hash: string;
+  };
+  sync_status: {
+    current_index: number;
+    stage: string;
+    synced: boolean;
+  };
+  peers: Array<{
+    peer_id: string;
+  }>;
+};
+
+export type FetchAccountBalanceResponse = {
+  block_identifier: {
+    index: number;
+    hash: string;
+  };
+  balances: Array<{
+    value: string;
+    currency: {
+      symbol: string;
+      decimals: number;
+    };
+    metadata: {
+      locked_balance: number;
+      liquid_balance: number;
+      total_balance: number;
+    };
+  }>;
+  metadata: {
+    created_via_historical_lookup: boolean;
+    nonce: string;
+  };
+};
+
+export type RosettaTransaction = {
+  block_identifier: {
+    index: number;
+    hash: string;
+  };
+  transaction: {
+    transaction_identifier: {
+      hash: string;
+    };
+    operations: Array<{
+      operation_identifier: {
+        index: number;
+      };
+      type:
+        | "fee_payment"
+        | "payment_source_dec"
+        | "payment_receiver_inc"
+        | "account_creation_fee_via_payment"
+        | "zkapp_fee_payer_dec"
+        | "delegate_change"
+        | "zkapp_balance_update";
+      status: "Success" | "Failed";
+      account: {
+        address: string;
+        metadata: {
+          token_id: string;
+        };
+      };
+      amount?: {
+        value: string;
+        currency: {
+          symbol: string;
+          decimals: number;
+        };
+      };
+      related_operations?: Array<{
+        index: number;
+      }>;
+      metadata?: {
+        delegate_change_target?: string;
+      };
+    }>;
+    metadata?: {
+      memo?: string;
+      nonce?: number;
+    };
+  };
+  timestamp: number;
+};
+
+export type FetchAccountTransactionsResponse = {
+  transactions: RosettaTransaction[];
+  total_count: number;
+  next_offset?: number;
+};
+
+export type RosettaPreprocessResponse = {
+  options: {
+    sender: string;
+    token_id: string;
+    receiver: string;
+  };
+};
+
+export type RosettaMetadataResponse = {
+  metadata: {
+    sender: string;
+    nonce: string;
+    token_id: string;
+    receiver: string;
+    account_creation_fee?: string;
+  };
+  suggested_fee: Array<{
+    value: string;
+    currency: {
+      symbol: string;
+      decimals: number;
+    };
+    metadata: {
+      minimum_fee: {
+        value: string;
+        currency: {
+          symbol: string;
+          decimals: number;
+        };
+      };
+    };
+  }>;
+};
+
+export type RosettaSubmitResponse = {
+  transaction_identifier: {
+    hash: string;
+  };
+};
+
+export type RosettaBlockInfoResponse = {
+  block: {
+    block_identifier: {
+      index: number;
+      hash: string;
+    };
+    parent_block_identifier: {
+      index: number;
+      hash: string;
+    };
+    timestamp: number;
+  };
+};

package/src/api/rosetta/utils.test.ts

@@ -0,0 +1,100 @@
+import { addNetworkIdentifier, buildAccountIdentifier, makeTransferPayload } from "./utils";
+import {
+  MINA_DECIMALS,
+  MINA_SYMBOL,
+  MINA_TOKEN_ID,
+  MAINNET_NETWORK_IDENTIFIER,
+} from "../../consts";
+
+describe("addNetworkIdentifier", () => {
+  it("should add network identifier to an empty object", () => {
+    const result = addNetworkIdentifier({});
+    expect(result).toEqual(MAINNET_NETWORK_IDENTIFIER);
+  });
+
+  it("should add network identifier to an object with existing properties", () => {
+    const testObj = { test: "value" };
+    const result = addNetworkIdentifier(testObj);
+    expect(result).toEqual({
+      ...MAINNET_NETWORK_IDENTIFIER,
+      test: "value",
+    });
+  });
+
+  it("should override network identifier properties if they exist in input object", () => {
+    // Assuming MAINNET_NETWORK_IDENTIFIER has a property like { blockchain: 'Mina' }
+    const testObj = { blockchain: "mina" };
+    const result = addNetworkIdentifier(testObj);
+    expect(result.network_identifier.blockchain).toEqual("mina");
+  });
+});
+
+describe("buildAccountIdentifier", () => {
+  it("should build correct account identifier with given address", () => {
+    const testAddress = "B62qrPN5Y5yq8kGE3FbVKbGTdTAJNdtNtB5sNVpxyRwWGcDEhpMzc8g";
+    const result = buildAccountIdentifier(testAddress);
+
+    expect(result).toEqual({
+      account_identifier: {
+        address: testAddress,
+        metadata: {
+          token_id: MINA_TOKEN_ID,
+        },
+      },
+    });
+  });
+});
+
+describe("makeTransferPayload", () => {
+  const fromAddr = "sender-address";
+  const toAddr = "recipient-address";
+  const feeNano = 1000000;
+  const valueNano = 5000000;
+
+  it("should create a valid transfer payload with three operations", () => {
+    const result = makeTransferPayload(fromAddr, toAddr, feeNano, valueNano);
+
+    expect(result.operations).toHaveLength(3);
+  });
+
+  it("should correctly create fee payment operation", () => {
+    const result = makeTransferPayload(fromAddr, toAddr, feeNano, valueNano);
+
+    const feeOp = result.operations[0];
+    expect(feeOp.operation_identifier.index).toBe(0);
+    expect(feeOp.type).toBe("fee_payment");
+    expect(feeOp.account.address).toBe(fromAddr);
+    expect(feeOp.amount.value).toBe("-" + feeNano.toString());
+    expect(feeOp.amount.currency.symbol).toBe(MINA_SYMBOL);
+    expect(feeOp.amount.currency.decimals).toBe(MINA_DECIMALS);
+  });
+
+  it("should correctly create payment source operation", () => {
+    const result = makeTransferPayload(fromAddr, toAddr, feeNano, valueNano);
+
+    const sourceOp = result.operations[1];
+    expect(sourceOp.operation_identifier.index).toBe(1);
+    expect(sourceOp.type).toBe("payment_source_dec");
+    expect(sourceOp.account.address).toBe(fromAddr);
+    expect(sourceOp.amount.value).toBe("-" + valueNano.toString());
+  });
+
+  it("should correctly create payment receiver operation with related operation", () => {
+    const result = makeTransferPayload(fromAddr, toAddr, feeNano, valueNano);
+
+    const receiverOp = result.operations[2];
+    expect(receiverOp.operation_identifier.index).toBe(2);
+    expect(receiverOp.type).toBe("payment_receiver_inc");
+    expect(receiverOp.account.address).toBe(toAddr);
+    expect(receiverOp.amount.value).toBe(valueNano.toString());
+    expect(receiverOp.relatedOps.related_operations).toEqual([{ index: 1 }]);
+  });
+
+  it("should handle zero values correctly", () => {
+    const result = makeTransferPayload(fromAddr, toAddr, 0, 0);
+
+    expect(result.operations[0].amount.value).toBe("-0");
+    expect(result.operations[1].amount.value).toBe("-0");
+    expect(result.operations[2].amount.value).toBe("0");
+  });
+});

package/src/api/rosetta/utils.ts

@@ -0,0 +1,71 @@
+import {
+  MINA_DECIMALS,
+  MINA_SYMBOL,
+  MINA_TOKEN_ID,
+  MAINNET_NETWORK_IDENTIFIER,
+} from "../../consts";
+
+export const addNetworkIdentifier = (data: object) => {
+  return {
+    ...MAINNET_NETWORK_IDENTIFIER,
+    ...data,
+  };
+};
+
+export const buildAccountIdentifier = (address: string) => {
+  return {
+    account_identifier: {
+      address,
+      metadata: {
+        token_id: MINA_TOKEN_ID,
+      },
+    },
+  };
+};
+
+export function makeTransferPayload(from: string, to: string, feeNano: number, valueNano: number) {
+  function makeOperation(
+    idx: number,
+    relatedIdxs: number[],
+    opType: string,
+    addr: string,
+    value: number,
+    isPositive: boolean,
+  ) {
+    const relatedOps =
+      relatedIdxs.length == 0
+        ? {}
+        : {
+            related_operations: relatedIdxs.map(i => {
+              return { index: i };
+            }),
+          };
+
+    return {
+      operation_identifier: { index: idx },
+      relatedOps,
+      type: opType,
+      account: {
+        address: addr,
+        metadata: {
+          token_id: MINA_TOKEN_ID,
+        },
+      },
+      amount: {
+        value: (isPositive ? "" : "-") + value.toString(),
+        currency: {
+          symbol: MINA_SYMBOL,
+          decimals: MINA_DECIMALS,
+        },
+      },
+    };
+  }
+
+  return {
+    operations: [
+      makeOperation(0, [], "fee_payment", from, feeNano, false),
+      makeOperation(1, [], "payment_source_dec", from, valueNano, false),
+      makeOperation(2, [1], "payment_receiver_inc", to, valueNano, true),
+    ],
+  };
+}

package/src/bridge/broadcast.test.ts

@@ -0,0 +1,35 @@
+import { Account, BroadcastArg } from "@ledgerhq/types-live";
+import broadcast from "./broadcast";
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("../api");
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcastTransaction as broadcastLogic } from "../api";
+
+describe("broadcast", () => {
+  let patchOperationSpy: jest.SpyInstance;
+  let broadcastSpy: jest.SpyInstance;
+  beforeEach(() => {
+    patchOperationSpy = jest.spyOn({ patchOperationWithHash }, "patchOperationWithHash");
+    broadcastSpy = jest.spyOn({ broadcastLogic }, "broadcastLogic");
+    broadcastSpy.mockResolvedValue("hash");
+  });
+
+  const signedOperation = {
+    signature: JSON.stringify({}),
+    operation: undefined,
+  };
+
+  it("should broadcast", () => {
+    broadcast({
+      signedOperation,
+    } as unknown as BroadcastArg<Account>);
+    expect(broadcastLogic).toHaveBeenCalledTimes(1);
+  });
+
+  it("should patch operation with hash", () => {
+    broadcast({
+      signedOperation,
+    } as unknown as BroadcastArg<Account>);
+    expect(patchOperationSpy).toHaveBeenCalledWith(undefined, "hash");
+  });
+});

package/src/bridge/broadcast.ts

@@ -0,0 +1,17 @@
+import type { Operation, SignedOperation } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcastTransaction } from "../api";
+import { MinaSignedTransaction } from "../types/common";
+
+const broadcast = async ({
+  signedOperation: { signature, operation },
+}: {
+  signedOperation: SignedOperation;
+}): Promise<Operation> => {
+  const signedPayload = JSON.parse(signature) as MinaSignedTransaction;
+  const hash = await broadcastTransaction(signedPayload);
+
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/bridge/buildTransaction.test.ts

@@ -0,0 +1,68 @@
+import { Account } from "@ledgerhq/types-live";
+import { buildTransaction } from "./buildTransaction";
+import { MINA_MAINNET_NETWORK_ID, MINA_PAYMENT_TYPE_ID } from "../consts";
+import { getAccountNumFromPath } from "../common-logic";
+import { BigNumber } from "bignumber.js";
+import { Transaction } from "../types";
+jest.mock("../common-logic");
+
+describe("buildTransaction", () => {
+  let getAccountNumSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getAccountNumSpy = jest.spyOn({ getAccountNumFromPath }, "getAccountNumFromPath");
+    getAccountNumSpy.mockReturnValue(42); // Mock account number
+  });
+
+  const mockAccount: Partial<Account> = {
+    freshAddress: "B62qrPN5Y5yq8kGE3FbVKbGTdTAJNdHm8qSqZhhtiu1Dq56Cmuo2aJ4",
+    freshAddressPath: "44'/12586'/0'/0/0",
+  };
+
+  const mockTransaction: Transaction = {
+    recipient: "B62qoDWfBZUxKpaoQCoMPJEysXXWv7reVgo7CEAjqx1xAYs3CsT8Gtz",
+    amount: new BigNumber(1000000000),
+    fees: {
+      fee: new BigNumber(1000000),
+      accountCreationFee: new BigNumber(0),
+    },
+    nonce: 5,
+    memo: "test transaction",
+    family: "mina",
+  };
+
+  it("should build a transaction correctly", async () => {
+    const result = await buildTransaction(mockAccount as Account, mockTransaction);
+
+    expect(result).toEqual({
+      txType: MINA_PAYMENT_TYPE_ID,
+      senderAccount: 42,
+      senderAddress: mockAccount.freshAddress,
+      receiverAddress: mockTransaction.recipient,
+      amount: mockTransaction.amount.toNumber(),
+      fee: mockTransaction.fees.fee.toNumber(),
+      nonce: mockTransaction.nonce,
+      memo: mockTransaction.memo,
+      networkId: MINA_MAINNET_NETWORK_ID,
+    });
+
+    expect(getAccountNumFromPath).toHaveBeenCalledWith(mockAccount.freshAddressPath);
+  });
+
+  it("should handle empty memo", async () => {
+    const txWithoutMemo = {
+      ...mockTransaction,
+      memo: undefined,
+    };
+
+    const result = await buildTransaction(mockAccount as Account, txWithoutMemo);
+
+    expect(result.memo).toBe("");
+  });
+
+  it("should throw error if accountNum is undefined", async () => {
+    getAccountNumSpy.mockReturnValue(undefined);
+
+    await expect(buildTransaction(mockAccount as Account, mockTransaction)).rejects.toThrow();
+  });
+});

package/src/bridge/buildTransaction.ts

@@ -0,0 +1,34 @@
+import { log } from "@ledgerhq/logs";
+import type { Account } from "@ledgerhq/types-live";
+import type { MinaUnsignedTransaction, Transaction } from "../types/common";
+import { MINA_MAINNET_NETWORK_ID, MINA_PAYMENT_TYPE_ID } from "../consts";
+import { getAccountNumFromPath } from "../common-logic";
+import invariant from "invariant";
+
+export const buildTransaction = async (
+  a: Account,
+  t: Transaction,
+): Promise<MinaUnsignedTransaction> => {
+  try {
+    const accountNum = getAccountNumFromPath(a.freshAddressPath);
+    invariant(accountNum !== undefined, "mina: accountNum is required to build transaction");
+    return {
+      txType: MINA_PAYMENT_TYPE_ID,
+      senderAccount: accountNum,
+      senderAddress: a.freshAddress,
+      receiverAddress: t.recipient,
+      amount: t.amount.toNumber(),
+      fee: t.fees.fee.toNumber(),
+      nonce: t.nonce,
+      memo: t.memo ?? "",
+      networkId: MINA_MAINNET_NETWORK_ID,
+    };
+  } catch (e) {
+    log("error", "mina: error building transaction", {
+      error: e,
+      transaction: t,
+      account: a,
+    });
+    throw e;
+  }
+};

package/src/bridge/cli-transaction.ts

@@ -0,0 +1,43 @@
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { Transaction } from "../types/common";
+
+const options = [
+  {
+    name: "memo",
+    type: String,
+    desc: "set a memo",
+  },
+];
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "mina", "mina family");
+  return [account];
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, string>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "mina", "mina family");
+
+    return {
+      ...transaction,
+      family: "mina",
+      memo: opts.memo,
+    };
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/bridge/createTransaction.test.ts

@@ -0,0 +1,21 @@
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { createTransaction } from "./createTransaction";
+import BigNumber from "bignumber.js";
+
+describe("createTransaction", () => {
+  it("should create a 0 amount transaction", () => {
+    expect(createTransaction({} as AccountLike<Account>).amount.toNumber()).toEqual(0);
+    expect(createTransaction({} as AccountLike<Account>).recipient).toEqual("");
+    expect(createTransaction({} as AccountLike<Account>).useAllAmount).toEqual(false);
+    expect(createTransaction({} as AccountLike<Account>).fees).toEqual({
+      fee: new BigNumber(0),
+      accountCreationFee: new BigNumber(0),
+    });
+    expect(createTransaction({} as AccountLike<Account>).memo).toEqual(undefined);
+    expect(createTransaction({} as AccountLike<Account>).nonce).toEqual(0);
+  });
+
+  it("should create a transaction with boilerplate family", () => {
+    expect(createTransaction({} as AccountLike<Account>).family).toEqual("mina");
+  });
+});

package/src/bridge/createTransaction.ts

@@ -0,0 +1,19 @@
+import BigNumber from "bignumber.js";
+import { MinaAccount, Transaction } from "../types/common";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+export const createTransaction: AccountBridge<
+  Transaction,
+  MinaAccount
+>["createTransaction"] = () => ({
+  family: "mina",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: {
+    fee: new BigNumber(0),
+    accountCreationFee: new BigNumber(0),
+  },
+  memo: undefined,
+  nonce: 0,
+});

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,15 @@
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "../types/common";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+
+function getDeviceTransactionConfig(_input: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/errors.ts

@@ -0,0 +1,16 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+/*
+ * When the memo is greater than 32 characters
+ */
+export const InvalidMemoMina = createCustomErrorClass("InvalidMemoMina");
+
+/*
+ * When the user sends less than the account creation fee of 1 MINA
+ */
+export const AccountCreationFeeWarning = createCustomErrorClass("AccountCreationFeeWarning");
+
+/*
+ * When the amount is less than the account creation fee of 1 MINA
+ */
+export const AmountTooSmall = createCustomErrorClass("AmountTooSmall");

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import type { Transaction, MinaAccount } from "../types/common";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { getMaxAmount } from "../common-logic";
+import { createTransaction } from "./createTransaction";
+import getEstimatedFees from "./getEstimatedFees";
+
+const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  MinaAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }): Promise<BigNumber> => {
+  const a = getMainAccount(account, parentAccount) as MinaAccount;
+  const t = {
+    ...createTransaction(account),
+    ...transaction,
+    amount: a.spendableBalance,
+  };
+
+  const { fee } = await getEstimatedFees(t, a.freshAddress);
+
+  const maxSpendable = getMaxAmount(a, t, fee);
+
+  if (maxSpendable.lt(0)) {
+    return new BigNumber(0);
+  }
+
+  return maxSpendable;
+};
+
+export default estimateMaxSpendable;

package/src/bridge/getEstimatedFees.ts

@@ -0,0 +1,17 @@
+import { BigNumber } from "bignumber.js";
+import { getFees } from "../api";
+import { Transaction } from "../types/common";
+
+const getEstimatedFees = async (
+  transaction: Transaction,
+  address: string,
+): Promise<{
+  fee: BigNumber;
+  accountCreationFee: BigNumber;
+}> => {
+  const { fee, accountCreationFee } = await getFees(transaction, address);
+
+  return { fee, accountCreationFee };
+};
+
+export default getEstimatedFees;