@ledgerhq/coin-algorand 0.2.0-next.0

package/src/bridge.integration.test.ts

@@ -0,0 +1,312 @@
+import {
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+} from "@ledgerhq/errors";
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { AlgorandASANotOptInInRecipient } from "./errors";
+import type { AlgorandTransaction, Transaction } from "./types";
+
+const algorand: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: [
+    "algorandResources.rewards", // We cant keep track of this since it's always moving
+    "balance", // Rewards are included, same as above
+    "spendableBalance", // Same since the rewards are included here too
+  ],
+  scanAccounts: [
+    {
+      name: "algorand seed 1",
+      apdus: `
+      => 800300000480000000
+      <= c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c49000
+      => 800300000480000000
+      <= c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c49000
+      => 800300000480000001
+      <= 21b3068ca2b9a3b0b1fc68d9ecbd61663f6957c68a9c767aa14a8abb437180e69000
+      => 800300000480000002
+      <= cc2b54ea5cbda5de6957086a8435c43a06e26559b2bfaebec56b748ec5a2a0519000
+      => 800300000480000003
+      <= 6104eb314f51f4db5733976bd8c066297019ebaa6adcf39b4aa318d553c571cc9000
+      => 800300000480000004
+      <= 6549e16ee1e242aba9d116dab058b6e33e4c6d801d3cbfe860195fc6e42940319000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      FIXME_tests: ["balance is sum of ops"],
+      // Rewards issues
+      raw: {
+        id: "js:2:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:",
+        seedIdentifier:
+          "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
+        name: "Algorand 1",
+        xpub: "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
+        derivationMode: "",
+        index: 0,
+        freshAddress:
+          "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
+        freshAddressPath: "44'/283'/0'/0/0",
+        freshAddresses: [
+          {
+            address:
+              "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
+            derivationPath: "44'/283'/0'/0/0",
+          },
+        ],
+        unitMagnitude: 6,
+        blockHeight: 8518049,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "algorand",
+        lastSyncDate: "",
+        balance: "1167089",
+        spendableBalance: "567089",
+        subAccounts: [],
+      },
+      transactions: [
+        {
+          name: "Same as Recipient",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber(100),
+            recipient:
+              "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Account creation minimum amount too low",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber("100"),
+            recipient:
+              "MVE6C3XB4JBKXKORC3NLAWFW4M7EY3MADU6L72DADFP4NZBJIAYXGSLN3Y",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalanceBecauseDestinationNotCreated(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "send",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber("1000"),
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "send amount more than fees + base reserve",
+          transaction: (t, account) => ({
+            ...t,
+            amount: account.balance,
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "send more than base reserve",
+          transaction: (t, account) => ({
+            ...t,
+            amount: account.balance.minus("100"),
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "optIn",
+          transaction: (t) => ({
+            ...t,
+            mode: "optIn",
+            assetId: "algorand/asa/31231",
+            amount: new BigNumber("1000"),
+            recipient:
+              "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {},
+            amount: new BigNumber("0"),
+          },
+        },
+        {
+          name: "Can't send ASA to an address that didn't Opt-in",
+          transaction: (t) => ({
+            ...t,
+            subAccountId:
+              "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
+            amount: new BigNumber("1000"),
+            recipient:
+              "ZQVVJ2S4XWS542KXBBVIINOEHIDOEZKZWK725PWFNN2I5RNCUBI53RT2EY",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new AlgorandASANotOptInInRecipient(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "send Token",
+          transaction: (t) => ({
+            ...t,
+            subAccountId:
+              "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
+            amount: new BigNumber("1000"),
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {},
+            amount: new BigNumber("1000"),
+          },
+        },
+        {
+          name: "send Token - more than available",
+          transaction: (t) => ({
+            ...t,
+            subAccountId:
+              "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
+            amount: new BigNumber("100000000000"),
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "send max",
+          transaction: (t) => ({
+            ...t,
+            recipient:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+            useAllAmount: true,
+          }),
+          expectedStatus: (account, _, status) => {
+            return {
+              amount: account.spendableBalance.minus(status.estimatedFees),
+              warnings: {},
+              errors: {},
+            };
+          },
+        },
+      ],
+    },
+    {
+      raw: {
+        id: "js:2:algorand:MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI:",
+        seedIdentifier:
+          "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
+        xpub: "6104eb314f51f4db5733976bd8c066297019ebaa6adcf39b4aa318d553c571cc",
+        name: "Algorand 4",
+        derivationMode: "",
+        index: 3,
+        freshAddress:
+          "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+        freshAddressPath: "44'/283'/3'/0/0",
+        freshAddresses: [
+          {
+            address:
+              "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
+            derivationPath: "44'/283'/3'/0/0",
+          },
+        ],
+        unitMagnitude: 6,
+        blockHeight: 8518189,
+        balance: "0",
+        spendableBalance: "0",
+        currencyId: "algorand",
+        lastSyncDate: "",
+        operations: [],
+        pendingOperations: [],
+      },
+      transactions: [
+        {
+          name: "Can't send funds if balance too low",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber("1000"),
+            recipient:
+              "YWZPDCL5XQPCPGBXKB7KAG7YF2QGCGEX37YTSM55CPEPHKNE2ZSKRAXNQ4",
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "Can't send ASA if Algo balance too low",
+          transaction: (t) => ({
+            ...t,
+            subAccountId:
+              "js:2:algorand:MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI:+312769",
+            amount: new BigNumber("1000000"),
+            recipient:
+              "YWZPDCL5XQPCPGBXKB7KAG7YF2QGCGEX37YTSM55CPEPHKNE2ZSKRAXNQ4",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<AlgorandTransaction> = {
+  implementations: ["js"],
+  currencies: {
+    algorand,
+  },
+};
+
+describe("Algorand bridge", () => {
+  test.todo(
+    "This is an empty test to make jest command pass. Remove it once there is a real test."
+  );
+});
+
+/**
+ * NOTE: if tests are added to this file,
+ * like done in libs/coin-polkadot/src/bridge.integration.test.ts for example,
+ * this file fill need to be imported in ledger-live-common
+ * libs/ledger-live-common/src/families/algorand/bridge.integration.test.ts
+ * like done for polkadot.
+ * cf.
+ * - libs/coin-polkadot/src/bridge.integration.test.ts
+ * - libs/ledger-live-common/src/families/polkadot/bridge.integration.test.ts
+ */

package/src/buildTransaction.ts

@@ -0,0 +1,98 @@
+import { encode as msgpackEncode } from "algo-msgpack-with-bigint";
+import type {
+  EncodedSignedTransaction as AlgoSignedTransactionPayload,
+  Transaction as AlgoTransaction,
+  EncodedTransaction as AlgoTransactionPayload,
+} from "algosdk";
+import {
+  makeAssetTransferTxnWithSuggestedParams,
+  makePaymentTxnWithSuggestedParams,
+} from "algosdk";
+
+import type { Account } from "@ledgerhq/types-live";
+import { AlgorandAPI } from "./api";
+import { extractTokenId } from "./tokens";
+import type { Transaction } from "./types";
+
+export const buildTransactionPayload =
+  (algorandAPI: AlgorandAPI) =>
+  async (
+    account: Account,
+    transaction: Transaction
+  ): Promise<AlgoTransactionPayload> => {
+    const { amount, recipient, mode, memo, assetId, subAccountId } =
+      transaction;
+    const subAccount = subAccountId
+      ? account.subAccounts &&
+        account.subAccounts.find((t) => t.id === subAccountId)
+      : null;
+
+    const note = memo ? new TextEncoder().encode(memo) : undefined;
+
+    const params = await algorandAPI.getTransactionParams();
+
+    let algoTxn: AlgoTransaction;
+    if (subAccount || (assetId && mode === "optIn")) {
+      const targetAssetId =
+        subAccount && subAccount.type === "TokenAccount"
+          ? extractTokenId(subAccount.token.id)
+          : assetId
+          ? extractTokenId(assetId)
+          : "";
+
+      if (!targetAssetId) {
+        throw new Error("Token Asset Id not found");
+      }
+
+      algoTxn = makeAssetTransferTxnWithSuggestedParams(
+        account.freshAddress,
+        recipient,
+        undefined,
+        undefined,
+        amount.toNumber(),
+        note,
+        Number(targetAssetId),
+        params,
+        undefined
+      );
+    } else {
+      algoTxn = makePaymentTxnWithSuggestedParams(
+        account.freshAddress,
+        recipient,
+        amount.toNumber(),
+        undefined,
+        note,
+        params
+      );
+    }
+
+    // Bit of safety: set tx validity to the next 1000 blocks
+    algoTxn.firstRound = params.lastRound;
+    algoTxn.lastRound = params.lastRound + 1000;
+
+    // Flaw in the SDK: payload isn't sorted, but it needs to be for msgPack encoding
+    const sorted = Object.fromEntries(
+      Object.entries(algoTxn.get_obj_for_encoding()).sort()
+    ) as AlgoTransactionPayload;
+
+    return sorted;
+  };
+
+export const encodeToSign = (payload: AlgoTransactionPayload): string => {
+  const msgPackEncoded = msgpackEncode(payload);
+
+  return Buffer.from(msgPackEncoded).toString("hex");
+};
+
+export const encodeToBroadcast = (
+  payload: AlgoTransactionPayload,
+  signature: Buffer
+): Buffer => {
+  const signedPayload: AlgoSignedTransactionPayload = {
+    sig: signature,
+    txn: payload,
+  };
+  const msgPackEncoded = msgpackEncode(signedPayload);
+
+  return Buffer.from(msgPackEncoded);
+};

package/src/cli-transaction.ts

@@ -0,0 +1,124 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import type {
+  Account,
+  AccountLike,
+  AccountLikeArray,
+} from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import { extractTokenId } from "./tokens";
+import type { AlgorandAccount, Transaction } from "./types";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, optIn, claimReward",
+  },
+  {
+    name: "fees",
+    type: String,
+    desc: "how much fees",
+  },
+  {
+    name: "gasLimit",
+    type: String,
+    desc: "how much gasLimit. default is estimated with the recipient",
+  },
+  {
+    name: "memo",
+    type: String,
+    desc: "set a memo",
+  },
+  {
+    name: "token",
+    alias: "t",
+    type: String,
+    desc: "use an token account children of the account",
+    multiple: true,
+  },
+];
+
+function inferAccounts(
+  account: Account,
+  opts: Record<string, any>
+): AccountLikeArray {
+  invariant(account.currency.family === "algorand", "algorand family");
+
+  if (!opts.token || opts.mode === "optIn") {
+    const accounts: Account[] = [account];
+    return accounts;
+  }
+
+  return opts.token.map((token?: string) => {
+    const subAccounts = account.subAccounts || [];
+
+    if (token) {
+      const subAccount = subAccounts.find((t) => {
+        const currency = getAccountCurrency(t);
+        return (
+          token.toLowerCase() === currency.ticker.toLowerCase() ||
+          token.toLowerCase() === extractTokenId(currency.id)
+        );
+      });
+
+      if (!subAccount) {
+        throw new Error(
+          "token account '" +
+            token +
+            "' not found. Available: " +
+            subAccounts.map((t) => getAccountCurrency(t).ticker).join(", ")
+        );
+      }
+
+      return subAccount;
+    }
+  });
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+  { inferAmount }: any
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "algorand", "algorand family");
+
+    if (account.type === "Account") {
+      invariant(
+        (account as AlgorandAccount).algorandResources,
+        "unactivated account"
+      );
+    }
+
+    if (account.type === "TokenAccount") {
+      const isDelisted = account.token.delisted === true;
+      invariant(!isDelisted, "token is delisted");
+    }
+
+    return {
+      ...transaction,
+      family: "algorand",
+      fees: opts.fees ? inferAmount(account, opts.fees) : null,
+      memo: opts.memo,
+      mode: opts.mode || "send",
+      subAccountId: account.type === "TokenAccount" ? account.id : null,
+      assetId: opts.token ? "algorand/asa/" + opts.token : null,
+    };
+  });
+}
+
+/**
+ * FIXME: unsued network and cache params are passed to makeCliTools because of how the
+ * libs/ledger-live-common/scripts/sync-families-dispatch.mjs script works.
+ */
+export default function makeCliTools(_network: unknown, _cache: unknown) {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,146 @@
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import {
+  findTokenById,
+  formatCurrencyUnit,
+} from "@ledgerhq/coin-framework/currencies/index";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { AccountLike } from "@ledgerhq/types-live";
+import { extractTokenId } from "./tokens";
+import type {
+  AlgorandTransaction,
+  Transaction,
+  TransactionStatus,
+} from "./types";
+
+export type ExtraDeviceTransactionField = {
+  type: "polkadot.validators";
+  label: string;
+};
+
+export const displayTokenValue = (token: TokenCurrency) =>
+  `${token.name} (#${extractTokenId(token.id)})`;
+
+const getSendFields = (
+  transaction: Transaction,
+  status: TransactionStatus,
+  account: AccountLike,
+  addRecipient: boolean
+) => {
+  const { estimatedFees, amount } = status;
+  const fields: {
+    type: string;
+    label: string;
+    value?: string;
+    address?: string;
+  }[] = [];
+  fields.push({
+    type: "text",
+    label: "Type",
+    value: account.type === "TokenAccount" ? "Asset xfer" : "Payment",
+  });
+
+  if (estimatedFees && !estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fee",
+    });
+  }
+
+  if (addRecipient) {
+    fields.push({
+      type: "address",
+      label: "Recipient",
+      address: transaction.recipient,
+    });
+  }
+
+  if (account.type === "TokenAccount") {
+    fields.push({
+      type: "text",
+      label: "Asset ID",
+      value: displayTokenValue(account.token),
+    });
+  }
+
+  if (amount) {
+    fields.push({
+      type: "text",
+      label: account.type === "TokenAccount" ? "Asset amt" : "Amount",
+      value: formatCurrencyUnit(getAccountUnit(account), amount, {
+        showCode: true,
+        disableRounding: true,
+      }),
+    });
+  }
+
+  return fields;
+};
+
+function getDeviceTransactionConfig({
+  account,
+  transaction,
+  status,
+}: {
+  account: AccountLike;
+  transaction: AlgorandTransaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const { mode, assetId } = transaction;
+  const { estimatedFees } = status;
+  let fields: {
+    type: string;
+    label: string;
+    value?: string;
+    address?: string;
+  }[] = [];
+
+  switch (mode) {
+    case "send":
+      fields = getSendFields(transaction, status, account, false);
+      break;
+
+    case "claimReward":
+      fields = getSendFields(transaction, status, account, true);
+      break;
+
+    case "optIn":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Asset xfer",
+      });
+
+      if (estimatedFees && !estimatedFees.isZero()) {
+        fields.push({
+          type: "fees",
+          label: "Fee",
+        });
+      }
+
+      if (assetId) {
+        const token = findTokenById(assetId);
+        fields.push({
+          type: "text",
+          label: "Asset ID",
+          value: token
+            ? displayTokenValue(token)
+            : `#${extractTokenId(assetId)}`,
+        });
+      }
+
+      fields.push({
+        type: "text",
+        label: "Asset amt",
+        value: "0",
+      });
+      break;
+
+    default:
+      break;
+  }
+
+  return fields as Array<DeviceTransactionField>;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const AlgorandASANotOptInInRecipient = createCustomErrorClass(
+  "AlgorandASANotOptInInRecipient"
+);

package/src/hw-getAddress.ts

@@ -0,0 +1,14 @@
+import type { Resolver } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import Algorand from "@ledgerhq/hw-app-algorand";
+
+const resolver: Resolver = async (transport, { path, verify }) => {
+  const algorand = new Algorand(transport);
+  const r = await algorand.getAddress(path, verify || false);
+  return {
+    address: r.address,
+    publicKey: r.publicKey,
+    path,
+  };
+};
+
+export default resolver;

package/src/initAccount.ts

@@ -0,0 +1,10 @@
+import type { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import type { AlgorandAccount } from "./types";
+
+export function initAccount(r: Account): void {
+  (r as AlgorandAccount).algorandResources = {
+    rewards: new BigNumber(0),
+    nbAssets: r.subAccounts?.length ?? 0,
+  };
+}