@ledgerhq/coin-algorand 0.2.0-next.0

package/.eslintrc.js

@@ -0,0 +1,57 @@
+module.exports = {
+  parser: "@typescript-eslint/parser",
+  env: {
+    browser: true,
+    es6: true,
+    node: true,
+    jest: true,
+  },
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier",
+  ],
+  globals: {
+    Atomics: "readonly",
+    SharedArrayBuffer: "readonly",
+  },
+  plugins: ["@typescript-eslint", "prettier"],
+  rules: {
+    "no-console": ["error", { allow: ["warn", "error"] }],
+    "linebreak-style": ["error", "unix"],
+    semi: ["error", "always"],
+    "no-unused-vars": "off",
+    "import/prefer-default-export": 0,
+    "no-plusplus": 0,
+    "no-underscore-dangle": 0,
+    "prefer-template": 0,
+    "no-await-in-loop": 0,
+    "no-restricted-syntax": 0,
+    "consistent-return": 0,
+    "no-lonely-if": 0,
+    "no-use-before-define": 0,
+    "no-nested-ternary": 0,
+    "import/no-cycle": 0,
+    "no-multi-assign": 0,
+    "guard-for-in": 0,
+    "no-continue": 0,
+    "lines-between-class-members": 0,
+    "prefer-destructuring": 0,
+    "prettier/prettier": "error",
+    "@typescript-eslint/no-use-before-define": "off",
+    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    "@typescript-eslint/no-empty-function": "off",
+    "@typescript-eslint/no-namespace": ["error", { allowDeclarations: true }],
+    "@typescript-eslint/no-explicit-any": 0,
+    "@typescript-eslint/ban-types": [
+      "error",
+      {
+        extendDefaults: true,
+        types: {
+          "{}": false,
+        },
+      },
+    ],
+  },
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @ledgerhq/coin-algorand@0.1.0 build /home/runner/work/ledger-live/ledger-live/libs/coin-algorand
+> tsc && tsc -m ES6 --outDir lib-es
+

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @ledgerhq/coin-algorand
+
+## 0.2.0-next.0
+
+### Minor Changes
+
+- [#3306](https://github.com/LedgerHQ/ledger-live/pull/3306) [`77f990e207`](https://github.com/LedgerHQ/ledger-live/commit/77f990e2075c7c9a4be69b364e3754b449c7a546) Thanks [@chabroA](https://github.com/chabroA)! - Move algorand coin logic in own package
+
+### Patch Changes
+
+- Updated dependencies [[`77f990e207`](https://github.com/LedgerHQ/ledger-live/commit/77f990e2075c7c9a4be69b364e3754b449c7a546), [`817a8dd811`](https://github.com/LedgerHQ/ledger-live/commit/817a8dd8112ff7c4640852ab4e47ea0436df2ec1), [`77f990e207`](https://github.com/LedgerHQ/ledger-live/commit/77f990e2075c7c9a4be69b364e3754b449c7a546), [`22491091f7`](https://github.com/LedgerHQ/ledger-live/commit/22491091f7b4e06ee6a0cdf964498aa5b08d6eb0), [`745fbf2a54`](https://github.com/LedgerHQ/ledger-live/commit/745fbf2a54cdc34aea938d7fbe4c8b198dc36b54), [`7cf49e1919`](https://github.com/LedgerHQ/ledger-live/commit/7cf49e1919466836e9025693ed07b18ebf99041a)]:
+  - @ledgerhq/errors@6.12.6-next.0
+  - @ledgerhq/cryptoassets@9.6.0-next.0
+  - @ledgerhq/coin-framework@0.3.4-next.0
+  - @ledgerhq/live-env@0.3.0-next.0
+  - @ledgerhq/types-live@6.34.1-next.0
+  - @ledgerhq/devices@8.0.3-next.0
+  - @ledgerhq/hw-app-algorand@6.27.15-next.0

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  testPathIgnorePatterns: ["lib/", "lib-es/"],
+};

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@ledgerhq/coin-algorand",
+  "version": "0.2.0-next.0",
+  "description": "Ledger Algorand Coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "algo",
+    "Algorand",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-algorand",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "*": [
+        "lib/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "algo-msgpack-with-bigint": "^2.1.1",
+    "algosdk": "1.13.0",
+    "bignumber.js": "^9.1.0",
+    "expect": "^27.4.6",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "prando": "^6.0.1",
+    "rxjs": "^6.6.7",
+    "@ledgerhq/coin-framework": "^0.3.4-next.0",
+    "@ledgerhq/cryptoassets": "^9.6.0-next.0",
+    "@ledgerhq/devices": "^8.0.3-next.0",
+    "@ledgerhq/errors": "^6.12.6-next.0",
+    "@ledgerhq/hw-app-algorand": "^6.27.15-next.0",
+    "@ledgerhq/live-env": "^0.3.0-next.0",
+    "@ledgerhq/live-promise": "^0.0.1",
+    "@ledgerhq/types-cryptoassets": "^7.2.0",
+    "@ledgerhq/types-live": "^6.34.1-next.0"
+  },
+  "devDependencies": {
+    "@types/invariant": "^2.2.2",
+    "@types/jest": "^29.2.4",
+    "@types/lodash": "^4.14.191",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-typescript": "^3.0.0",
+    "eslint-formatter-pretty": "^3.0.1",
+    "eslint-plugin-prettier": "^3.4.0",
+    "eslint-plugin-typescript": "^0.14.0",
+    "jest": "^28.1.1",
+    "prettier": "^2.8.1",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.9.5"
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m ES6 --outDir lib-es",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest"
+  }
+}

package/src/account.ts

@@ -0,0 +1,76 @@
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import type { Account, Operation } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import invariant from "invariant";
+import type { AlgorandAccount, AlgorandResources } from "./types";
+
+function formatOperationSpecifics(
+  op: Operation,
+  unit: Unit | null | undefined
+): string {
+  const { rewards } = op.extra;
+  return rewards
+    ? " REWARDS : " +
+        `${
+          unit
+            ? formatCurrencyUnit(unit, new BigNumber(rewards), {
+                showCode: true,
+                disableRounding: true,
+              }).padEnd(16)
+            : rewards
+        }`
+    : "";
+}
+
+function formatAccountSpecifics(account: Account): string {
+  const { algorandResources } = account as AlgorandAccount;
+  invariant(algorandResources, "algorand account expected");
+  const unit = getAccountUnit(account);
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: true,
+  };
+  let str = " ";
+  str +=
+    formatCurrencyUnit(unit, account.spendableBalance, formatConfig) +
+    " spendable. ";
+
+  if ((algorandResources as AlgorandResources).rewards.gt(0)) {
+    str +=
+      formatCurrencyUnit(
+        unit,
+        (algorandResources as AlgorandResources).rewards,
+        formatConfig
+      ) + " rewards. ";
+  }
+
+  return str;
+}
+
+export function fromOperationExtraRaw(
+  extra: Record<string, any> | null | undefined
+) {
+  if (extra && extra.rewards) {
+    return { ...extra, rewards: new BigNumber(extra.rewards) };
+  }
+
+  return extra;
+}
+export function toOperationExtraRaw(
+  extra: Record<string, any> | null | undefined
+) {
+  if (extra && extra.rewards) {
+    return { ...extra, rewards: extra.rewards.toString() };
+  }
+
+  return extra;
+}
+export default {
+  formatAccountSpecifics,
+  formatOperationSpecifics,
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+};

package/src/api/algodv2.ts

@@ -0,0 +1,71 @@
+import { NetworkRequestCall } from "@ledgerhq/coin-framework/network";
+import { getEnv } from "@ledgerhq/live-env";
+import { BigNumber } from "bignumber.js";
+import {
+  AlgoAccount,
+  AlgoAsset,
+  AlgoTransactionBroadcastResponse,
+  AlgoTransactionParams,
+} from "./algodv2.types";
+
+const BASE_URL = getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
+const NODE_URL = `${BASE_URL}/ps2/v2`;
+
+const fullUrl = (route: string): string => `${NODE_URL}${route}`;
+
+export const getAccount =
+  (network: NetworkRequestCall) =>
+  async (address: string): Promise<AlgoAccount> => {
+    const { data } = await network({
+      method: "GET",
+      url: fullUrl(`/accounts/${address}`),
+    });
+
+    const assets: AlgoAsset[] = data.assets
+      ? // FIXME: what is the type of `a`?
+        data.assets.map((a: any): AlgoAsset => {
+          return {
+            assetId: a["asset-id"].toString(),
+            balance: new BigNumber(a.amount),
+          };
+        })
+      : [];
+
+    return {
+      round: data.round,
+      address: data.address,
+      balance: new BigNumber(data.amount),
+      pendingRewards: new BigNumber(data["pending-rewards"]),
+      assets,
+    };
+  };
+
+export const getTransactionParams =
+  (network: NetworkRequestCall) => async (): Promise<AlgoTransactionParams> => {
+    const { data } = await network({
+      method: "GET",
+      url: fullUrl(`/transactions/params`),
+    });
+
+    return {
+      fee: data["fee"],
+      minFee: data["min-fee"],
+      firstRound: data["first-round"] ?? 0,
+      lastRound: data["last-round"],
+      genesisID: data["genesis-id"],
+      genesisHash: data["genesis-hash"],
+    };
+  };
+
+export const broadcastTransaction =
+  (network: NetworkRequestCall) =>
+  async (payload: Buffer): Promise<string> => {
+    const { data }: { data: AlgoTransactionBroadcastResponse } = await network({
+      method: "POST",
+      url: fullUrl(`/transactions`),
+      data: payload,
+      headers: { "Content-Type": "application/x-binary" },
+    });
+
+    return data.txId;
+  };

package/src/api/algodv2.types.ts

@@ -0,0 +1,27 @@
+import { BigNumber } from "bignumber.js";
+
+export interface AlgoAccount {
+  round: number;
+  address: string;
+  balance: BigNumber;
+  pendingRewards: BigNumber;
+  assets: AlgoAsset[];
+}
+
+export interface AlgoAsset {
+  assetId: string;
+  balance: BigNumber;
+}
+
+export interface AlgoTransactionParams {
+  fee: number;
+  minFee: number;
+  firstRound: number;
+  lastRound: number;
+  genesisHash: string;
+  genesisID: string;
+}
+
+export interface AlgoTransactionBroadcastResponse {
+  txId: string;
+}

package/src/api/index.ts

@@ -0,0 +1,41 @@
+import { NetworkRequestCall } from "@ledgerhq/coin-framework/network";
+import { AlgoAccount, AlgoTransactionParams } from "./algodv2.types";
+
+import {
+  broadcastTransaction,
+  getAccount,
+  getTransactionParams,
+} from "./algodv2";
+
+import { getAccountTransactions } from "./indexer";
+import { AlgoTransaction } from "./indexer.types";
+
+export * from "./algodv2.types";
+export * from "./indexer.types";
+
+export class AlgorandAPI {
+  network: NetworkRequestCall;
+
+  constructor(network: NetworkRequestCall) {
+    this.network = network;
+  }
+
+  async getAccount(address: string): Promise<AlgoAccount> {
+    return getAccount(this.network)(address);
+  }
+
+  async getTransactionParams(): Promise<AlgoTransactionParams> {
+    return getTransactionParams(this.network)();
+  }
+
+  async broadcastTransaction(payload: Buffer): Promise<string> {
+    return broadcastTransaction(this.network)(payload);
+  }
+
+  async getAccountTransactions(
+    address: string,
+    startAt?: number
+  ): Promise<AlgoTransaction[]> {
+    return getAccountTransactions(this.network)(address, startAt);
+  }
+}

package/src/api/indexer.ts

@@ -0,0 +1,102 @@
+import { NetworkRequestCall } from "@ledgerhq/coin-framework/network";
+import { getEnv } from "@ledgerhq/live-env";
+import { BigNumber } from "bignumber.js";
+import {
+  AlgoAssetTransferInfo,
+  AlgoPaymentInfo,
+  AlgoTransaction,
+  AlgoTransactionDetails,
+} from "./indexer.types";
+
+const LIMIT = 100; // Max nb of transactions per request
+
+const BASE_URL = getEnv("API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
+const INDEXER_URL = `${BASE_URL}/idx2/v2`;
+
+const fullUrl = (route: string): string =>
+  `${INDEXER_URL}${route}?limit=${LIMIT}`;
+
+export const getAccountTransactions =
+  (network: NetworkRequestCall) =>
+  async (address: string, startAt?: number): Promise<AlgoTransaction[]> => {
+    const url = fullUrl(`/accounts/${address}/transactions`);
+
+    let nextToken: string | undefined;
+    let newRawTxs: any[] = [];
+    const mergedTxs: AlgoTransaction[] = [];
+    do {
+      let nextUrl: string = url;
+      if (startAt) {
+        nextUrl = nextUrl.concat(`&min-round=${startAt}`);
+      }
+      if (nextToken) {
+        nextUrl = nextUrl.concat(`&next=${nextToken}`);
+      }
+      const { data }: { data: { transactions: any[] } } = await network({
+        method: "GET",
+        url: nextUrl,
+      });
+
+      // FIXME: what is the correct type? Properly type response from api above (data)
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      nextToken = data["next-token"];
+      newRawTxs = data.transactions;
+      newRawTxs.map(parseRawTransaction).forEach((tx) => mergedTxs.push(tx));
+    } while (newRawTxs.length >= LIMIT);
+
+    return mergedTxs;
+  };
+
+const parseRawTransaction = (tx: any): AlgoTransaction => {
+  let details: AlgoTransactionDetails | undefined = undefined;
+  if (tx["tx-type"] === "pay") {
+    const info = tx["payment-transaction"];
+    const paymentInfo: AlgoPaymentInfo = {
+      amount: new BigNumber(info.amount),
+      recipientAddress: info.receiver,
+      closeAmount:
+        info["close-amount"] === undefined
+          ? undefined
+          : new BigNumber(info["close-amount"]),
+      closeToAddress: info["close-remainder-to"],
+    };
+    details = paymentInfo;
+  } else if (tx["tx-type"] === "axfer") {
+    const info = tx["asset-transfer-transaction"];
+    const assetTransferInfo: AlgoAssetTransferInfo = {
+      assetAmount: new BigNumber(info.amount),
+      assetId: info["asset-id"],
+      assetRecipientAddress: info.receiver,
+      assetSenderAddress: info.sender,
+      assetCloseAmount:
+        info["close-amount"] === undefined
+          ? undefined
+          : new BigNumber(info["close-amount"]),
+      assetCloseToAddress: tx["close-to"],
+    };
+    details = assetTransferInfo;
+  }
+
+  return {
+    id: tx.id,
+    timestamp: tx["round-time"],
+    round: tx["confirmed-round"],
+    senderAddress: tx.sender,
+    senderRewards: new BigNumber(tx["sender-rewards"]),
+    recipientRewards: new BigNumber(tx["receiver-rewards"]),
+    closeRewards:
+      tx["close-rewards"] === undefined
+        ? undefined
+        : new BigNumber(tx["close-rewards"]),
+    closeAmount:
+      tx["closing-amount"] === undefined
+        ? undefined
+        : new BigNumber(tx["closing-amount"]),
+    fee: new BigNumber(tx.fee),
+    note: tx.note,
+
+    type: tx["tx-type"],
+    details,
+  };
+};

package/src/api/indexer.types.ts

@@ -0,0 +1,41 @@
+import { BigNumber } from "bignumber.js";
+
+export type AlgoTransactionDetails = AlgoPaymentInfo | AlgoAssetTransferInfo;
+
+// Define only types we explicitely support
+export enum AlgoTransactionType {
+  PAYMENT = "pay",
+  ASSET_TRANSFER = "axfer",
+}
+
+export interface AlgoTransaction {
+  id: string;
+  timestamp: string; // 'round-time': 1597933539,
+  round: number; // 'confirmed-round': 8575676,
+  senderAddress: string; // sender: 'RGX5XA7DWZOZ5SLG4WQSNIFKIG4CNX4VOH23YCEX56523DQEAL3QL56XZM',
+  senderRewards: BigNumber; // 'sender-rewards': 0,
+  recipientRewards: BigNumber; //'receiver-rewards': 0,
+  closeRewards?: BigNumber; // 'close-rewards': 0,
+  closeAmount?: BigNumber; //'closing-amount': 0,
+  fee: BigNumber;
+  note: string;
+
+  type: string; // 'tx-type': 'pay'
+  details?: AlgoTransactionDetails;
+}
+
+export interface AlgoPaymentInfo {
+  amount: BigNumber;
+  recipientAddress: string; // receiver
+  closeAmount?: BigNumber; // close-amount
+  closeToAddress?: string; // close-remainder-to
+}
+
+export interface AlgoAssetTransferInfo {
+  assetId: string; // asset-id
+  assetAmount: BigNumber; // amount
+  assetRecipientAddress: string; // receiver
+  assetSenderAddress?: string; // sender
+  assetCloseAmount?: BigNumber; // close-amount
+  assetCloseToAddress?: string; // close-to
+}

package/src/bridge/js.ts

@@ -0,0 +1,92 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  DeviceCommunication,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { NetworkRequestCall } from "@ledgerhq/coin-framework/network";
+
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { AlgorandAPI } from "../api";
+import getAddress from "../hw-getAddress";
+import { initAccount } from "../initAccount";
+import { broadcast } from "../js-broadcast";
+import createTransaction from "../js-createTransaction";
+import { estimateMaxSpendable } from "../js-estimateMaxSpendable";
+import { getTransactionStatus } from "../js-getTransactionStatus";
+import prepareTransaction from "../js-prepareTransaction";
+import { buildSignOperation } from "../js-signOperation";
+import { makeGetAccountShape } from "../js-synchronization";
+import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
+import type { Transaction } from "../types";
+
+const updateTransaction = (t: Transaction, patch: Partial<Transaction>) => ({
+  ...t,
+  ...patch,
+});
+
+export function buildCurrencyBridge(
+  deviceCommunication: DeviceCommunication,
+  network: NetworkRequestCall
+): CurrencyBridge {
+  const algorandAPI = new AlgorandAPI(network);
+
+  const getAccountShape = makeGetAccountShape(algorandAPI);
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    deviceCommunication,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    preload: async () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  deviceCommunication: DeviceCommunication,
+  network: NetworkRequestCall
+): AccountBridge<Transaction> {
+  const algorandAPI = new AlgorandAPI(network);
+
+  const receive = makeAccountBridgeReceive(
+    getAddressWrapper(getAddress),
+    deviceCommunication
+  );
+  const signOperation = buildSignOperation(deviceCommunication, algorandAPI);
+  const getAccountShape = makeGetAccountShape(algorandAPI);
+  const sync = makeSync({ getAccountShape });
+
+  return {
+    createTransaction,
+    updateTransaction,
+    prepareTransaction: prepareTransaction(algorandAPI),
+    getTransactionStatus: getTransactionStatus(algorandAPI),
+    sync,
+    receive,
+    assignToAccountRaw,
+    assignFromAccountRaw,
+    initAccount,
+    signOperation,
+    broadcast: broadcast(algorandAPI),
+    estimateMaxSpendable: estimateMaxSpendable(algorandAPI),
+  };
+}
+
+/**
+ * FIXME: an unsued cacheFn is passed to createBridges because of how the
+ * libs/ledger-live-common/scripts/sync-families-dispatch.mjs script works.
+ */
+export function createBridges(
+  deviceCommunication: DeviceCommunication,
+  network: NetworkRequestCall,
+  _cacheFn: unknown
+) {
+  return {
+    currencyBridge: buildCurrencyBridge(deviceCommunication, network),
+    accountBridge: buildAccountBridge(deviceCommunication, network),
+  };
+}