@ledgerhq/coin-mina 1.1.0-next.0

package/src/bridge/signOperation.ts

@@ -0,0 +1,112 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { MinaOperation, MinaSignedTransaction, Transaction } from "../types/common";
+import type {
+  Account,
+  DeviceId,
+  SignOperationEvent,
+  OperationType,
+  AccountBridge,
+} from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { MinaSignature, MinaSigner } from "../types/signer";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { buildTransaction } from "./buildTransaction";
+import { reEncodeRawSignature } from "../common-logic";
+import invariant from "invariant";
+
+export const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction,
+  fee: BigNumber,
+): MinaOperation => {
+  let value = new BigNumber(transaction.amount).plus(fee);
+
+  if (transaction.fees?.accountCreationFee.gt(0)) {
+    value = value.minus(transaction.fees.accountCreationFee);
+  }
+
+  const type: OperationType = "OUT";
+
+  const operation: MinaOperation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee,
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    date: new Date(),
+    extra: {
+      memo: transaction.memo,
+      accountCreationFee: transaction.fees.accountCreationFee.toString(),
+    },
+  };
+
+  return operation;
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (signerContext: SignerContext<MinaSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: Transaction;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        o.next({ type: "device-signature-requested" });
+
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        const unsigned = await buildTransaction(account, transaction);
+
+        const { signature } = (await signerContext(deviceId, signer =>
+          signer.signTransaction(unsigned),
+        )) as MinaSignature;
+        invariant(signature, "signature should be defined if user accepted");
+        const encodedSignature = reEncodeRawSignature(signature);
+
+        const signedTransaction: MinaSignedTransaction = {
+          transaction: unsigned,
+          signature: encodedSignature,
+        };
+
+        o.next({ type: "device-signature-granted" });
+
+        const operation = buildOptimisticOperation(
+          account,
+          transaction,
+          transaction.fees.fee ?? new BigNumber(0),
+        );
+        const signedSerializedTx = JSON.stringify(signedTransaction);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signedSerializedTx,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });
+
+export default buildSignOperation;

package/src/bridge/synchronisation.test.ts

@@ -0,0 +1,184 @@
+import { getAccountShape, mapRosettaTxnToOperation } from "./synchronisation";
+jest.mock("@ledgerhq/coin-framework/account/accountId");
+jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers");
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("../api");
+
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/accountId";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getAccount, getTransactions, getBlockInfo } from "../api";
+import BigNumber from "bignumber.js";
+import {
+  createMockTxn,
+  createMockAccountInfo,
+  mockBlockInfo,
+  mockAccountData,
+} from "../test/fixtures";
+
+describe("synchronisation", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("mapRosettaTxnToOperation", () => {
+    const mockAccountId = "account_id";
+    const mockAddress = "sender_address";
+
+    beforeEach(() => {
+      jest.spyOn({ getBlockInfo }, "getBlockInfo").mockResolvedValue(mockBlockInfo);
+      jest
+        .spyOn({ encodeOperationId }, "encodeOperationId")
+        .mockReturnValue("encoded_operation_id");
+    });
+
+    it("should map payment transaction (OUT)", async () => {
+      const mockTxn = createMockTxn({
+        type: "OUT",
+        senderAddress: mockAddress,
+        receiverAddress: "receiver_address",
+        status: "Success",
+      });
+
+      const result = await mapRosettaTxnToOperation(mockAccountId, mockAddress, mockTxn);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        id: "encoded_operation_id",
+        type: "OUT",
+        hash: "tx_hash",
+        value: new BigNumber(900),
+        fee: new BigNumber(-100),
+        blockHeight: 123,
+        hasFailed: false,
+        blockHash: "block_hash",
+        accountId: mockAccountId,
+        senders: [mockAddress],
+        recipients: ["receiver_address"],
+        date: new Date(1672531200000),
+        extra: {
+          memo: "test memo",
+          accountCreationFee: "0",
+        },
+      });
+    });
+
+    it("should map payment transaction (IN)", async () => {
+      const mockTxn = createMockTxn({
+        type: "IN",
+        senderAddress: "sender_other",
+        receiverAddress: mockAddress,
+        status: "Success",
+      });
+
+      const result = await mapRosettaTxnToOperation(mockAccountId, mockAddress, mockTxn);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        id: "encoded_operation_id",
+        type: "IN",
+        hash: "tx_hash",
+        value: new BigNumber(1000),
+        fee: new BigNumber(-100),
+        blockHeight: 123,
+        hasFailed: false,
+        blockHash: "block_hash",
+        accountId: mockAccountId,
+        senders: ["sender_other"],
+        recipients: [mockAddress],
+        date: new Date(1672531200000),
+        extra: {
+          memo: "test memo",
+          accountCreationFee: "0",
+        },
+      });
+    });
+
+    it("should map redelegate transaction", async () => {
+      const mockTxn = createMockTxn({
+        type: "REDELEGATE",
+        senderAddress: mockAddress,
+        receiverAddress: "not_used",
+        memo: "redelegate",
+        status: "Success",
+      });
+
+      const result = await mapRosettaTxnToOperation(mockAccountId, mockAddress, mockTxn);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        id: "encoded_operation_id",
+        type: "REDELEGATE",
+        hash: "tx_hash",
+        value: new BigNumber(0),
+        fee: new BigNumber(0),
+        blockHeight: 123,
+        hasFailed: false,
+        blockHash: "block_hash",
+        accountId: mockAccountId,
+        senders: [mockAddress],
+        recipients: ["unknown"],
+        date: new Date(1672531200000),
+        extra: {
+          memo: "redelegate",
+          accountCreationFee: "0",
+        },
+      });
+    });
+
+    it("should handle failed transactions", async () => {
+      const mockTxn = createMockTxn({
+        type: "OUT",
+        senderAddress: mockAddress,
+        receiverAddress: "receiver_address",
+        status: "Failed",
+        memo: "failed",
+      });
+
+      const result = await mapRosettaTxnToOperation(mockAccountId, mockAddress, mockTxn);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].hasFailed).toBe(true);
+    });
+  });
+
+  describe("getAccountShape", () => {
+    beforeEach(() => {
+      jest.spyOn({ encodeAccountId }, "encodeAccountId").mockReturnValue("account_id");
+      jest.spyOn({ getAccount }, "getAccount").mockResolvedValue(mockAccountData);
+      jest.spyOn({ getTransactions }, "getTransactions").mockResolvedValue([]);
+      jest.spyOn({ mergeOps }, "mergeOps").mockReturnValue([]);
+    });
+
+    it("should get account shape with correct data", async () => {
+      const mockInfo = createMockAccountInfo();
+      const result = await getAccountShape(mockInfo, {
+        paginationConfig: {
+          operationsPerAccountId: {
+            account_id: 10,
+          },
+        },
+      });
+
+      expect(encodeAccountId).toHaveBeenCalledWith({
+        type: "js",
+        version: "2",
+        currencyId: "mina",
+        xpubOrAddress: "test_address",
+        derivationMode: "minabip44",
+      });
+
+      expect(getAccount).toHaveBeenCalledWith("test_address");
+      expect(getTransactions).toHaveBeenCalledWith("test_address", 0);
+
+      expect(result).toEqual({
+        id: "account_id",
+        balance: mockAccountData.balance,
+        spendableBalance: mockAccountData.spendableBalance,
+        blockHeight: mockAccountData.blockHeight,
+        operationsCount: 0,
+        operations: [],
+      });
+    });
+  });
+});

package/src/bridge/synchronisation.ts

@@ -0,0 +1,168 @@
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/accountId";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { makeSync, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getAccount, getBlockInfo, getTransactions } from "../api";
+import { MinaAccount, MinaOperation } from "../types/common";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import BigNumber from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import invariant from "invariant";
+import { RosettaTransaction } from "../api/rosetta/types";
+
+export const mapRosettaTxnToOperation = async (
+  accountId: string,
+  address: string,
+  txn: RosettaTransaction,
+): Promise<MinaOperation[]> => {
+  try {
+    const hash = txn.transaction.transaction_identifier.hash;
+    const blockHeight = txn.block_identifier.index;
+    const blockHash = txn.block_identifier.hash;
+    const date = new Date(txn.timestamp ?? (await getBlockInfo(blockHeight)).block.timestamp);
+    const memo = txn.transaction.metadata?.memo || "";
+
+    let value = new BigNumber(0);
+    let fee = new BigNumber(0);
+    let accountCreationFee = new BigNumber(0);
+
+    let fromAccount: string = "";
+    let toAccount: string = "";
+    let isSending = false;
+    let failed = false;
+    let redelegateTransaction = false;
+
+    for (const op of txn.transaction.operations) {
+      failed = failed || op.status === "Failed";
+      const opValue = failed ? new BigNumber(0) : new BigNumber(op.amount?.value ?? 0);
+      switch (op.type) {
+        case "fee_payment": {
+          fee = fee.plus(opValue.times(-1));
+          continue;
+        }
+        case "payment_receiver_inc": {
+          toAccount = op.account.address;
+          value = value.plus(opValue);
+          continue;
+        }
+        case "payment_source_dec": {
+          fromAccount = op.account.address;
+          if (fromAccount === address) {
+            isSending = true;
+          }
+          continue;
+        }
+        case "zkapp_fee_payer_dec": {
+          fromAccount = op.account.address;
+          continue;
+        }
+        case "zkapp_balance_update": {
+          toAccount = op.account.address;
+          value = value.plus(opValue);
+          continue;
+        }
+        case "delegate_change": {
+          fromAccount = op.account.address;
+          toAccount = op.metadata?.delegate_change_target || toAccount || "unknown";
+          redelegateTransaction = true;
+          continue;
+        }
+        case "account_creation_fee_via_payment": {
+          accountCreationFee = opValue.times(-1);
+          continue;
+        }
+      }
+    }
+
+    invariant(fromAccount, "mina: missing fromAccount");
+    invariant(toAccount, "mina: missing toAccount");
+
+    const op: MinaOperation = {
+      id: "",
+      type: "NONE",
+      hash,
+      value,
+      fee,
+      blockHeight,
+      hasFailed: failed,
+      blockHash,
+      accountId,
+      senders: [fromAccount],
+      recipients: [toAccount],
+      date,
+      extra: {
+        memo,
+        accountCreationFee: accountCreationFee.toString(),
+      },
+    };
+
+    const ops: MinaOperation[] = [];
+    if (isSending) {
+      const type = "OUT";
+      ops.push({
+        ...op,
+        value: value.minus(accountCreationFee).plus(fee),
+        type,
+        id: encodeOperationId(accountId, hash, type),
+      });
+    } else if (redelegateTransaction) {
+      // delegate change
+      const type = "REDELEGATE";
+      ops.push({
+        ...op,
+        value: new BigNumber(0),
+        type,
+        id: encodeOperationId(accountId, hash, type),
+      });
+    } else {
+      const type = "IN";
+      ops.push({
+        ...op,
+        value: value.minus(accountCreationFee),
+        type,
+        id: encodeOperationId(accountId, hash, type),
+      });
+    }
+
+    return ops;
+  } catch (e) {
+    log("error", "mina: failed to convert txn to operation", {
+      error: e,
+      transaction: txn,
+    });
+    return [];
+  }
+};
+
+export const getAccountShape: GetAccountShape<MinaAccount> = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  const { blockHeight, balance, spendableBalance } = await getAccount(address);
+
+  const rosettaTxns = await getTransactions(address, initialAccount?.operations.length);
+  const newOperations = await Promise.all(
+    rosettaTxns.flatMap(t => mapRosettaTxnToOperation(accountId, address, t)),
+  );
+
+  const operations = mergeOps(oldOperations, newOperations.flat());
+
+  const shape: Partial<MinaAccount> = {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: operations.length,
+    blockHeight,
+  };
+
+  return { ...shape, operations };
+};
+
+export const sync = makeSync({ getAccountShape });

package/src/bridge/transaction.ts

@@ -0,0 +1,69 @@
+import type { Transaction, TransactionRaw } from "../types/common";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import BigNumber from "bignumber.js";
+
+export const formatTransaction = (
+  { recipient, useAllAmount, amount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+}
+TO ${recipient}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    fees: {
+      fee: new BigNumber(tr.fees.fee),
+      accountCreationFee: new BigNumber(tr.fees.accountCreationFee),
+    },
+    amount: new BigNumber(tr.amount),
+    memo: tr.memo,
+    nonce: tr.nonce,
+  };
+};
+
+const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...common,
+    family: t.family,
+    amount: t.amount.toFixed(),
+    fees: {
+      fee: t.fees.fee.toString(),
+      accountCreationFee: t.fees.accountCreationFee.toString(),
+    },
+    memo: t.memo ?? undefined,
+    nonce: t.nonce,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};