@ledgerhq/coin-near 0.3.8

package/src/preload.ts

@@ -0,0 +1,143 @@
+import { BigNumber } from "bignumber.js";
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import type { NearPreloadedData } from "./types";
+import { getProtocolConfig, getValidators, getCommission, getGasPrice } from "./api";
+import { FALLBACK_STORAGE_AMOUNT_PER_BYTE } from "./constants";
+import { NearProtocolConfigNotLoaded } from "./errors";
+
+const PRELOAD_MAX_AGE = 30 * 60 * 1000;
+
+let currentPreloadedData: NearPreloadedData = {
+  storageCost: new BigNumber(FALLBACK_STORAGE_AMOUNT_PER_BYTE),
+  gasPrice: new BigNumber(0),
+  createAccountCostSend: new BigNumber(0),
+  createAccountCostExecution: new BigNumber(0),
+  transferCostSend: new BigNumber(0),
+  transferCostExecution: new BigNumber(0),
+  addKeyCostSend: new BigNumber(0),
+  addKeyCostExecution: new BigNumber(0),
+  receiptCreationSend: new BigNumber(0),
+  receiptCreationExecution: new BigNumber(0),
+  validators: [],
+};
+
+function fromHydratePreloadData(data: any): NearPreloadedData {
+  const hydratedData = Object.assign({}, currentPreloadedData);
+
+  if (typeof data === "object" && data) {
+    if (data.storageCost) {
+      hydratedData.storageCost = new BigNumber(data.storageCost);
+    }
+    if (data.gasPrice) {
+      hydratedData.gasPrice = new BigNumber(data.gasPrice);
+    }
+    if (data.createAccountCostSend) {
+      hydratedData.createAccountCostSend = new BigNumber(data.createAccountCostSend);
+    }
+    if (data.createAccountCostExecution) {
+      hydratedData.createAccountCostExecution = new BigNumber(data.createAccountCostExecution);
+    }
+    if (data.transferCostSend) {
+      hydratedData.transferCostSend = new BigNumber(data.transferCostSend);
+    }
+    if (data.transferCostExecution) {
+      hydratedData.transferCostExecution = new BigNumber(data.transferCostExecution);
+    }
+    if (data.addKeyCostSend) {
+      hydratedData.addKeyCostSend = new BigNumber(data.addKeyCostSend);
+    }
+    if (data.addKeyCostExecution) {
+      hydratedData.addKeyCostExecution = new BigNumber(data.addKeyCostExecution);
+    }
+    if (data.receiptCreationSend) {
+      hydratedData.receiptCreationSend = new BigNumber(data.receiptCreationSend);
+    }
+    if (data.receiptCreationExecution) {
+      hydratedData.receiptCreationExecution = new BigNumber(data.receiptCreationExecution);
+    }
+    if (Array.isArray(data.validators) && data.validators.length) {
+      hydratedData.validators = data.validators;
+    }
+  }
+
+  return hydratedData;
+}
+
+const updates = new Subject<NearPreloadedData>();
+
+export function getCurrentNearPreloadData(): NearPreloadedData {
+  return currentPreloadedData;
+}
+
+export function setNearPreloadData(data: NearPreloadedData): void {
+  if (data === currentPreloadedData) return;
+
+  currentPreloadedData = data;
+
+  updates.next(data);
+}
+
+export function getNearPreloadDataUpdates(): Observable<NearPreloadedData> {
+  return updates.asObservable();
+}
+
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: PRELOAD_MAX_AGE,
+});
+
+export const preload = async (): Promise<NearPreloadedData> => {
+  log("near/preload", "preloading near data...");
+
+  const [protocolConfig, rawValidators, gasPrice] = await Promise.all([
+    getProtocolConfig(),
+    getValidators(),
+    getGasPrice(),
+  ]);
+
+  const validators = await Promise.all(
+    rawValidators.map(async ({ account_id, stake }) => {
+      const commission = await getCommission(account_id);
+
+      return {
+        validatorAddress: account_id,
+        tokens: stake,
+        commission,
+      };
+    }),
+  );
+
+  if (!protocolConfig) {
+    throw new NearProtocolConfigNotLoaded();
+  }
+
+  const { storage_amount_per_byte, transaction_costs } = protocolConfig.runtime_config;
+
+  const { action_creation_config, action_receipt_creation_config } = transaction_costs;
+
+  return {
+    storageCost: new BigNumber(storage_amount_per_byte),
+    gasPrice: new BigNumber(gasPrice),
+    createAccountCostSend: new BigNumber(action_creation_config.create_account_cost.send_not_sir),
+    createAccountCostExecution: new BigNumber(action_creation_config.create_account_cost.execution),
+    transferCostSend: new BigNumber(action_creation_config.transfer_cost.send_not_sir),
+    transferCostExecution: new BigNumber(action_creation_config.transfer_cost.execution),
+    addKeyCostSend: new BigNumber(
+      action_creation_config.add_key_cost.full_access_cost.send_not_sir,
+    ),
+    addKeyCostExecution: new BigNumber(
+      action_creation_config.add_key_cost.full_access_cost.execution,
+    ),
+    receiptCreationSend: new BigNumber(action_receipt_creation_config.send_not_sir),
+    receiptCreationExecution: new BigNumber(action_receipt_creation_config.execution),
+    validators,
+  };
+};
+
+export const hydrate = (data: any): void => {
+  const hydrated = fromHydratePreloadData(data);
+
+  log("near/preload", `hydrated storageCost with ${hydrated.storageCost}`);
+
+  setNearPreloadData(hydrated);
+};

package/src/serialization.ts

@@ -0,0 +1,61 @@
+import { BigNumber } from "bignumber.js";
+import type { NearAccount, NearAccountRaw, NearResources, NearResourcesRaw } from "./types";
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+
+export function toNearResourcesRaw(r: NearResources): NearResourcesRaw {
+  const { stakedBalance, pendingBalance, availableBalance, storageUsageBalance, stakingPositions } =
+    r;
+  return {
+    stakedBalance: stakedBalance.toString(),
+    pendingBalance: pendingBalance.toString(),
+    availableBalance: availableBalance.toString(),
+    storageUsageBalance: storageUsageBalance.toString(),
+    stakingPositions: stakingPositions.map(
+      ({ staked, validatorId, available, pending, rewards }) => ({
+        staked: staked.toString(),
+        available: available.toString(),
+        pending: pending.toString(),
+        rewards: rewards.toString(),
+        validatorId,
+      }),
+    ),
+  };
+}
+
+export function fromNearResourcesRaw(r: NearResourcesRaw): NearResources {
+  const {
+    stakedBalance,
+    pendingBalance,
+    availableBalance,
+    storageUsageBalance,
+    stakingPositions = [],
+  } = r;
+  return {
+    stakedBalance: new BigNumber(stakedBalance),
+    pendingBalance: new BigNumber(pendingBalance),
+    availableBalance: new BigNumber(availableBalance),
+    storageUsageBalance: new BigNumber(storageUsageBalance),
+    stakingPositions: stakingPositions.map(
+      ({ staked, validatorId, available, pending, rewards }) => ({
+        staked: new BigNumber(staked),
+        available: new BigNumber(available),
+        pending: new BigNumber(pending),
+        rewards: new BigNumber(rewards),
+        validatorId,
+      }),
+    ),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const nearAccount = account as NearAccount;
+  if (nearAccount.nearResources) {
+    (accountRaw as NearAccountRaw).nearResources = toNearResourcesRaw(nearAccount.nearResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const nearResourcesRaw = (accountRaw as NearAccountRaw).nearResources;
+  if (nearResourcesRaw)
+    (account as NearAccount).nearResources = fromNearResourcesRaw(nearResourcesRaw);
+}

package/src/signer.ts

@@ -0,0 +1,9 @@
+export type NearAddress = {
+  publicKey: string;
+  address: string;
+};
+export type NearSignature = Buffer | undefined;
+export interface NearSigner {
+  getAddress(path: string, verify?: boolean): Promise<NearAddress>;
+  signTransaction(transaction: Uint8Array, path: string): Promise<NearSignature>;
+}

package/src/specs.ts

@@ -0,0 +1,177 @@
+import invariant from "invariant";
+import expect from "expect";
+import { BigNumber } from "bignumber.js";
+import type { Transaction, NearAccount } from "./types";
+import {
+  getCryptoCurrencyById,
+  parseCurrencyUnit,
+} from "@ledgerhq/coin-framework/currencies/index";
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { acceptTransaction } from "./speculos-deviceActions";
+
+const currency = getCryptoCurrencyById("near");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.00001");
+const stakingFee = parseCurrencyUnit(currency.units[0], "0.002");
+const maxAccount = 8;
+const validator = "ledgerbyfigment.poolv1.near";
+
+const near: AppSpec<Transaction> = {
+  name: "NEAR",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "NEAR",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 2 * 60 * 1000,
+  mutations: [
+    {
+      name: "Move 50% to another account",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient }, { amount }],
+        };
+      },
+      test: ({ accountBeforeTransaction, operation, account }) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expect(account.spendableBalance).toEqual(
+            accountBeforeTransaction.spendableBalance.minus(operation.value),
+          ),
+        );
+      },
+    },
+    {
+      name: "Send max to another account",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient }, { useAllAmount: true }],
+        };
+      },
+      test: ({ account }) => {
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toString()).toBe("0"),
+        );
+      },
+    },
+    {
+      name: "Stake",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount.plus(stakingFee)), "balance is too low");
+
+        const amount = minimalAmount.times(10).times(Math.random()).integerValue();
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ mode: "stake", recipient: validator }, { amount }],
+        };
+      },
+      test: ({ accountBeforeTransaction, operation, account }) => {
+        const { nearResources } = account as NearAccount;
+        const { nearResources: beforeTransactionNearResources } =
+          accountBeforeTransaction as NearAccount;
+
+        // Sometimes, 1 yoctoNEAR gets deducted from the staked amount, so we assert against a range.
+        botTest("account staked balance increased with operation", () => {
+          expect(
+            nearResources.stakedBalance.gte(
+              beforeTransactionNearResources.stakedBalance.plus(operation.value.minus("1")),
+            ),
+          ).toBe(true);
+          expect(
+            nearResources.stakedBalance.lte(
+              beforeTransactionNearResources.stakedBalance.plus(operation.value),
+            ),
+          ).toBe(true);
+        });
+      },
+    },
+    {
+      name: "Unstake",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(stakingFee), "balance is too low for fees");
+
+        const { nearResources } = account as NearAccount;
+
+        const staked = nearResources?.stakedBalance || new BigNumber(0);
+
+        invariant(staked.gt(minimalAmount), "staked balance is too low for unstaking");
+
+        const halfStaked = staked.div(2);
+
+        const amount = halfStaked.gt(minimalAmount)
+          ? halfStaked.integerValue()
+          : staked.integerValue();
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ mode: "unstake", recipient: validator }, { amount }],
+        };
+      },
+      test: ({ accountBeforeTransaction, account }) => {
+        const { nearResources } = account as NearAccount;
+        const { nearResources: beforeTransactionNearResources } =
+          accountBeforeTransaction as NearAccount;
+
+        botTest("account pending balance increased", () =>
+          expect(
+            nearResources.pendingBalance.gt(beforeTransactionNearResources.pendingBalance),
+          ).toBe(true),
+        );
+      },
+    },
+    {
+      name: "Withdraw",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(stakingFee), "balance is too low for fees");
+
+        const { nearResources } = account as NearAccount;
+
+        const available = nearResources?.availableBalance || new BigNumber(0);
+
+        invariant(available.gt(minimalAmount), "available balance is too low for withdrawing");
+
+        const halfAvailable = available.div(2);
+
+        const amount = halfAvailable.gt(minimalAmount)
+          ? halfAvailable.integerValue()
+          : available.integerValue();
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ mode: "withdraw", recipient: validator }, { amount }],
+        };
+      },
+      test: ({ accountBeforeTransaction, account }) => {
+        const { nearResources } = account as NearAccount;
+        const { nearResources: beforeTransactionNearResources } =
+          accountBeforeTransaction as NearAccount;
+
+        botTest("account withdrawable balance decreased", () =>
+          expect(
+            nearResources.availableBalance.lt(beforeTransactionNearResources.availableBalance),
+          ).toBe(true),
+        );
+      },
+    },
+  ],
+};
+
+export default {
+  near,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,75 @@
+import * as nearAPI from "near-api-js";
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+import { deviceActionFlow, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+const confirmWording: Record<string, string> = {
+  send: "transfer",
+  stake: "deposit_and_stake",
+  unstake: "unstake",
+  withdraw: "withdraw",
+};
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Confirm",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => confirmWording[transaction.mode],
+    },
+    {
+      title: "Deposit",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) => {
+        if (transaction.mode === "stake") {
+          return formatCurrencyUnit(getAccountUnit(account), transaction.amount, {
+            disableRounding: true,
+          });
+        }
+
+        return "0";
+      },
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) =>
+        formatCurrencyUnit(getAccountUnit(account), transaction.amount, {
+          disableRounding: true,
+        }),
+    },
+    {
+      title: "To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "From",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Args",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) => {
+        if (transaction.mode === "stake") {
+          return "{}";
+        }
+
+        return JSON.stringify({
+          amount: nearAPI.utils.format.parseNearAmount(
+            formatCurrencyUnit(getAccountUnit(account), transaction.amount, {
+              disableRounding: true,
+            }),
+          ),
+        });
+      },
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+      final: true,
+    },
+  ],
+});

package/src/transaction.ts

@@ -0,0 +1,57 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  formatTransactionStatusCommon as formatTransactionStatus,
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/transaction/common";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+export const formatTransaction = (
+  { mode, amount, recipient, useAllAmount }: Transaction,
+  account: Account,
+): string => `
+${mode.toUpperCase()} ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+    ? ""
+    : " " +
+      formatCurrencyUnit(getAccountUnit(account), amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}${recipient ? `\nTO ${recipient}` : ""}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    mode: tr.mode,
+    fees: new BigNumber(tr?.fees || 0),
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    fees: t.fees?.toString(),
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/types.ts

@@ -0,0 +1,91 @@
+import type { BigNumber } from "bignumber.js";
+import {
+  Account,
+  AccountRaw,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import type { NearStakingPosition } from "./api/sdk.types";
+
+export type { NearStakingPosition } from "./api/sdk.types";
+
+export type Transaction = TransactionCommon & {
+  family: "near";
+  mode: string;
+  fees?: BigNumber;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "near";
+  mode: string;
+  fees?: string;
+};
+
+export type NearPreloadedData = {
+  storageCost: BigNumber;
+  gasPrice: BigNumber;
+  createAccountCostSend: BigNumber;
+  createAccountCostExecution: BigNumber;
+  transferCostSend: BigNumber;
+  transferCostExecution: BigNumber;
+  addKeyCostSend: BigNumber;
+  addKeyCostExecution: BigNumber;
+  receiptCreationSend: BigNumber;
+  receiptCreationExecution: BigNumber;
+  validators: NearValidatorItem[];
+};
+
+export type NearResources = {
+  stakedBalance: BigNumber;
+  availableBalance: BigNumber;
+  pendingBalance: BigNumber;
+  storageUsageBalance: BigNumber;
+  stakingPositions: NearStakingPosition[];
+};
+
+export type NearResourcesRaw = {
+  stakedBalance: string;
+  availableBalance: string;
+  pendingBalance: string;
+  storageUsageBalance: string;
+  stakingPositions: {
+    staked: string;
+    available: string;
+    pending: string;
+    rewards: string;
+    validatorId: string;
+  }[];
+};
+
+export type NearAccount = Account & { nearResources: NearResources };
+
+export type NearAccountRaw = AccountRaw & {
+  nearResources: NearResourcesRaw;
+};
+
+export type NearValidatorItem = {
+  validatorAddress: string;
+  commission: number | null;
+  tokens: string;
+};
+
+export type NearMappedStakingPosition = NearStakingPosition & {
+  formattedAmount: string;
+  formattedRewards: string;
+  formattedPending: string;
+  formattedAvailable: string;
+  rank: number;
+  validator: NearValidatorItem | null | undefined;
+};
+
+export type StatusErrorMap = {
+  recipient?: Error;
+  amount?: Error;
+  fees?: Error;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;

package/tsconfig.json

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