@ledgerhq/coin-mina 1.1.0-next.0

package/src/test/bot-specs.ts

@@ -0,0 +1,130 @@
+import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import expect from "expect";
+
+import type { MinaOperation, Transaction } from "../types/common";
+import { genericTestDestination, botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec, TransactionTestInput } from "@ledgerhq/coin-framework/bot/types";
+import { acceptTransaction } from "./bot-deviceActions";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { getRandomTransferID } from "./testUtils";
+
+const maxAccount = 6;
+// 0.1 MINA
+const MIN_SAFE = new BigNumber(1 * 10 ** 8);
+
+const minaSpecs: AppSpec<Transaction> = {
+  name: "Mina",
+  currency: getCryptoCurrencyById("mina"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Mina",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 15 * 60 * 1000,
+  minViableAmount: MIN_SAFE,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "Send ~50% to another account",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      feature: "send",
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+
+        const transaction = bridge.createTransaction(account);
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient,
+          },
+          { amount },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memo: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+
+      test: ({
+        accountBeforeTransaction,
+        operation,
+        account,
+        transaction,
+      }: TransactionTestInput<Transaction>) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expect(account.spendableBalance).toEqual(
+            accountBeforeTransaction.spendableBalance
+              .minus(operation.value)
+              .minus((operation.extra as MinaOperation["extra"]).accountCreationFee),
+          ),
+        );
+
+        if (transaction.memo) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memo,
+            }),
+          );
+        }
+      },
+    },
+    {
+      name: "Transfer Max",
+      feature: "sendMax",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient: pickSiblings(siblings, maxAccount).freshAddress,
+          },
+          {
+            useAllAmount: true,
+          },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memo: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates,
+        };
+      },
+      testDestination: genericTestDestination,
+      test: ({ account, transaction, operation }) => {
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toString()).toBe("0"),
+        );
+
+        if (transaction.memo) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memo,
+            }),
+          );
+        }
+      },
+    },
+  ],
+};
+
+export default {
+  minaSpecs,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,180 @@
+import { BigNumber } from "bignumber.js";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+import type { DatasetTest, CurrenciesData } from "@ledgerhq/types-live";
+import type { Transaction } from "../types/common";
+import { fromTransactionRaw } from "../bridge/transaction";
+import { InvalidMemoMina } from "../bridge/errors";
+
+const ACCOUNT_ADDRESS = "B62qjWLs1W3J2fFGixeX49w1o7VvSGuMBNotnFhzs3PZ7PbtdFbhdeD";
+const ACCOUNT_ADDRESS_1 = "B62qkWcHhoisWDCR7v3gvWzX6wXEVuGYLHXq3mSym4GEzfYXmSDv314";
+
+const mina: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: ["blockHash"],
+  scanAccounts: [
+    {
+      name: "mina seed 1",
+      apdus: `
+      => e00201000400000000
+      <= 423632716a574c733157334a3266464769786558343977316f3756765347754d424e6f746e46687a7333505a3750627464466268646544009000
+      => e00201000400000001
+      <= 423632716e4438387474693632364d694d6e7568504d624c69504c766664644657486a47667377795646754c5845614b644b366f344263009000
+      => e00201000400000002
+      <= 423632716a7048577878544457506e474372714b546b56414b596f4e5250374c6e454b356564766d717151394658736e61313166674741009000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      // Skipping due to rewards being auto-compounded, no operation as evidence
+      FIXME_tests: ["balance is sum of ops"],
+      raw: {
+        id: `js:2:mina:${ACCOUNT_ADDRESS}:`,
+        seedIdentifier: `${ACCOUNT_ADDRESS}`,
+        name: "MINA 1",
+        derivationMode: "minabip44",
+        index: 0,
+        freshAddress: `${ACCOUNT_ADDRESS}`,
+        freshAddressPath: "44'/12586'/0'/0'/0'",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "mina",
+        lastSyncDate: "",
+        balance: "1000000",
+      },
+      transactions: [
+        {
+          name: "not a valid address",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: "novalidaddress",
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            amount: "1000",
+            memo: undefined,
+            nonce: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "not enough balance",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: ACCOUNT_ADDRESS_1,
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            amount: (300 * 1e9).toString(),
+            memo: undefined,
+            nonce: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "invalid Memo",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: ACCOUNT_ADDRESS_1,
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            amount: "1000",
+            memo: "string greated than 32 chars is invalid",
+            nonce: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              transaction: new InvalidMemoMina(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "amount Required",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: ACCOUNT_ADDRESS_1,
+            memo: undefined,
+            amount: "0",
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            nonce: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "recipient same as source",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: ACCOUNT_ADDRESS,
+            amount: "10",
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            memo: undefined,
+            nonce: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "new account and sufficient amount",
+          transaction: fromTransactionRaw({
+            family: "mina",
+            recipient: ACCOUNT_ADDRESS_1,
+            amount: "1000",
+            fees: {
+              fee: new BigNumber(0).toString(),
+              accountCreationFee: new BigNumber(0).toString(),
+            },
+            memo: undefined,
+            nonce: 0,
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1000"),
+            errors: {},
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    mina,
+  },
+};

package/src/test/fixtures.ts

@@ -0,0 +1,226 @@
+import { Account } from "@ledgerhq/types-live";
+import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/lib/currencies";
+import BigNumber from "bignumber.js";
+import { RosettaBlockInfoResponse, RosettaTransaction } from "../api/rosetta/types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { MinaUnsignedTransaction } from "@ledgerhq/coin-mina/types";
+import { DeviceId } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { MinaSigner } from "@ledgerhq/coin-mina/types";
+import { Transaction } from "../types";
+
+// Mock account data
+export const mockAccountData = {
+  blockHeight: 123,
+  balance: new BigNumber(1000),
+  spendableBalance: new BigNumber(900),
+};
+
+// Mock block info
+export const mockBlockInfo: RosettaBlockInfoResponse = {
+  block: {
+    block_identifier: { index: 123, hash: "block_hash" },
+    parent_block_identifier: { index: 122, hash: "parent_block_hash" },
+    timestamp: 1672531200000,
+  },
+};
+
+/**
+ * Creates a mock Rosetta transaction for testing
+ */
+export const createMockTxn = (options: {
+  type: string;
+  senderAddress: string;
+  receiverAddress: string;
+  status: "Success" | "Failed";
+  amount?: string;
+  fee?: string;
+  memo?: string;
+}): RosettaTransaction => {
+  const {
+    type,
+    senderAddress,
+    receiverAddress,
+    amount = "1000",
+    fee = "100",
+    memo = "test memo",
+    status,
+  } = options;
+
+  const operations: RosettaTransaction["transaction"]["operations"] = [];
+
+  if (type !== "REDELEGATE") {
+    // Add fee operation for payment transactions
+    operations.push({
+      type: "fee_payment",
+      amount: { value: fee, currency: { symbol: "MINA", decimals: 9 } },
+      status,
+      account: { address: senderAddress, metadata: { token_id: "MINA" } },
+      operation_identifier: { index: 0 },
+    });
+
+    operations.push({
+      type: "payment_source_dec",
+      status,
+      account: { address: senderAddress, metadata: { token_id: "MINA" } },
+      operation_identifier: { index: 1 },
+    });
+
+    operations.push({
+      type: "payment_receiver_inc",
+      amount: { value: amount, currency: { symbol: "MINA", decimals: 9 } },
+      status,
+      account: { address: receiverAddress, metadata: { token_id: "MINA" } },
+      operation_identifier: { index: 2 },
+    });
+  } else {
+    // Delegate change operation
+    operations.push({
+      type: "delegate_change",
+      status,
+      account: { address: senderAddress, metadata: { token_id: "MINA" } },
+      operation_identifier: { index: 0 },
+    });
+  }
+
+  return {
+    transaction: {
+      transaction_identifier: { hash: "tx_hash" },
+      operations,
+      metadata: { memo },
+    },
+    block_identifier: { index: 123, hash: "block_hash" },
+    timestamp: 1672531200000,
+  };
+};
+
+/**
+ * Creates a mock account info object for testing
+ */
+export const createMockAccountInfo = (): AccountShapeInfo<Account> => ({
+  address: "test_address",
+  index: 0,
+  derivationPath: "m/44'/12586'/0'/0/0",
+  initialAccount: {
+    operations: [],
+    type: "Account",
+    id: "account_id",
+    seedIdentifier: "seed_identifier",
+    derivationMode: "minabip44",
+    index: 0,
+    freshAddress: "fresh_address",
+    freshAddressPath: "fresh_address_path",
+    used: true,
+    balance: new BigNumber(1000),
+    spendableBalance: new BigNumber(900),
+    creationDate: new Date(),
+    blockHeight: 123,
+    currency: getCryptoCurrencyById("mina") as CryptoCurrency,
+    operationsCount: 0,
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    subAccounts: [],
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+    syncHash: undefined,
+    nfts: [],
+  },
+  currency: getCryptoCurrencyById("mina") as CryptoCurrency,
+  derivationMode: "minabip44",
+});
+
+/**
+ * Creates a mock Mina account for testing
+ */
+export const createMockAccount = (overrides?: Partial<Account>): Account => ({
+  id: "mock_account_id",
+  freshAddress: "B62qiVhtBtqakq8sNTHdCTXn6tETSK6gtsmNHRn1WdLqjGLpsHbw1xc",
+  freshAddressPath: "44'/12586'/0'/0/0",
+  type: "Account",
+  seedIdentifier: "seed_identifier",
+  derivationMode: "minabip44",
+  index: 0,
+  used: true,
+  balance: new BigNumber(1000),
+  spendableBalance: new BigNumber(900),
+  creationDate: new Date(),
+  blockHeight: 123,
+  currency: getCryptoCurrencyById("mina") as CryptoCurrency,
+  operationsCount: 0,
+  pendingOperations: [],
+  lastSyncDate: new Date(),
+  subAccounts: [],
+  balanceHistoryCache: {
+    HOUR: { latestDate: null, balances: [] },
+    DAY: { latestDate: null, balances: [] },
+    WEEK: { latestDate: null, balances: [] },
+  },
+  swapHistory: [],
+  syncHash: undefined,
+  nfts: [],
+  operations: [],
+  ...overrides,
+});
+
+/**
+ * Creates a mock Mina transaction for testing
+ */
+export const createMockTransaction = (overrides?: Partial<Transaction>): Transaction => ({
+  family: "mina",
+  amount: new BigNumber(1000),
+  recipient: "B62qr5cXFjdnZXYxP5dEwRY7wENxcod4Q2oLxUDiq1QrBXZZyxMH8q4",
+  fees: {
+    fee: new BigNumber(10),
+    accountCreationFee: new BigNumber(0),
+  },
+  memo: "test memo",
+  nonce: 1,
+  ...overrides,
+});
+
+/**
+ * Creates a mock unsigned transaction for testing
+ */
+export const createMockUnsignedTransaction = (
+  account: Partial<Account> = createMockAccount(),
+  transaction: Partial<Transaction> = createMockTransaction(),
+): MinaUnsignedTransaction => ({
+  txType: 0,
+  senderAccount: 0,
+  senderAddress: account.freshAddress!,
+  receiverAddress: transaction.recipient!,
+  amount: transaction.amount!.toNumber(),
+  fee: transaction.fees!.fee.toNumber(),
+  nonce: transaction.nonce!,
+  memo: transaction.memo!,
+  networkId: 1,
+});
+
+/**
+ * Creates a mock device ID for testing
+ */
+export const mockDeviceId: DeviceId = "mock_device_id";
+
+/**
+ * Creates a mock signer context for testing
+ */
+export const createMockSignerContext = (
+  signatureResponse: { returnCode: string; signature: string } = {
+    returnCode: "0x9000",
+    signature: "mock_raw_signature",
+  },
+): SignerContext<MinaSigner> =>
+  jest.fn().mockImplementation((deviceId, cb) => {
+    const mockSigner: MinaSigner = {
+      getAddress: jest.fn(),
+      signTransaction: jest.fn().mockResolvedValue(signatureResponse),
+    };
+    return cb(mockSigner);
+  });
+
+// ... existing code ...

package/src/test/index.ts

@@ -0,0 +1,3 @@
+export * from "./bridgeDatasetTest";
+export * from "./bot-specs";
+export * from "./bot-deviceActions";

package/src/test/testUtils.test.ts

@@ -0,0 +1,9 @@
+import { getRandomTransferID } from "./testUtils";
+
+describe("testUtils", () => {
+  it("getRandomTransferID", () => {
+    const id = getRandomTransferID();
+    expect(id).toBeDefined();
+    expect(id.length).toBeGreaterThan(0);
+  });
+});

package/src/test/testUtils.ts

@@ -0,0 +1,3 @@
+export const getRandomTransferID = () => {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+};

package/src/types/common.ts

@@ -0,0 +1,70 @@
+import type { BigNumber } from "bignumber.js";
+import {
+  Account,
+  AccountRaw,
+  Operation,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+
+export type Transaction = TransactionCommon & {
+  family: "mina";
+  fees: {
+    fee: BigNumber;
+    accountCreationFee: BigNumber;
+  };
+  memo: string | undefined;
+  nonce: number;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "mina";
+  fees: {
+    fee: string;
+    accountCreationFee: string;
+  };
+  memo: string | undefined;
+  nonce: number;
+};
+
+export type MinaAccount = Account;
+
+export type MinaAPIAccount = {
+  blockHeight: number;
+  balance: BigNumber;
+  spendableBalance: BigNumber;
+};
+
+export type MinaAccountRaw = AccountRaw;
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type StatusErrorMap = {
+  recipient?: Error;
+  amount?: Error;
+  fees?: Error;
+  transaction?: Error;
+};
+
+export type MinaUnsignedTransaction = {
+  txType: number;
+  senderAccount: number;
+  senderAddress: string;
+  receiverAddress: string;
+  amount: number;
+  fee: number;
+  nonce: number;
+  memo: string;
+  networkId: number;
+};
+
+export interface MinaSignedTransaction {
+  signature: string;
+  transaction: MinaUnsignedTransaction;
+}
+
+export type MinaOperation = Operation<{ memo: string | undefined; accountCreationFee: string }>;

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./common";
+export * from "./signer";

package/src/types/signer.ts

@@ -0,0 +1,29 @@
+interface SignTransactionArgs {
+  txType: number;
+  senderAccount: number;
+  senderAddress: string;
+  receiverAddress: string;
+  amount: number;
+  fee: number;
+  nonce: number;
+  validUntil?: number;
+  memo?: string;
+  networkId: number;
+}
+interface BaseLedgerResponse {
+  returnCode: string;
+  statusText?: string;
+  message?: string;
+}
+interface SignTransactionResponse extends BaseLedgerResponse {
+  signature?: string | null;
+}
+
+export interface GetAddressResponse extends BaseLedgerResponse {
+  publicKey?: string | null;
+}
+export type MinaSignature = { signature?: string };
+export interface MinaSigner {
+  getAddress(account?: number, verify?: boolean): Promise<GetAddressResponse>;
+  signTransaction(transaction: SignTransactionArgs): Promise<SignTransactionResponse>;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib",
+    "exactOptionalPropertyTypes": true,
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}