@ledgerhq/coin-algorand 0.2.0-next.0

package/src/js-synchronization.ts

@@ -0,0 +1,429 @@
+import {
+  emptyHistoryCache,
+  encodeAccountId,
+  inferSubOperations,
+} from "@ledgerhq/coin-framework/account/index";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import {
+  findTokenById,
+  listTokensForCryptoCurrency,
+} from "@ledgerhq/coin-framework/currencies/index";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { promiseAllBatched } from "@ledgerhq/live-promise";
+import { BigNumber } from "bignumber.js";
+
+import type {
+  AlgoAsset,
+  AlgoAssetTransferInfo,
+  AlgoPaymentInfo,
+  AlgoTransaction,
+  AlgorandAPI,
+} from "./api";
+
+import { AlgoTransactionType } from "./api";
+
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type {
+  Account,
+  Operation,
+  OperationType,
+  SyncConfig,
+  TokenAccount,
+} from "@ledgerhq/types-live";
+import { computeAlgoMaxSpendable } from "./logic";
+import { addPrefixToken, extractTokenId } from "./tokens";
+
+const getASAOperationAmount = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): BigNumber => {
+  let assetAmount = new BigNumber(0);
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    const assetSender = details.assetSenderAddress
+      ? details.assetSenderAddress
+      : transaction.senderAddress;
+
+    // Account is either sender or recipient (if both the balance is unchanged)
+    if (
+      (assetSender === accountAddress) !==
+      (details.assetRecipientAddress == accountAddress)
+    ) {
+      assetAmount = assetAmount.plus(details.assetAmount);
+    }
+    // Account is either sender or close-to, but not both
+    if (
+      (assetSender === accountAddress) !==
+      (details.assetCloseToAddress &&
+        details.assetCloseToAddress === accountAddress)
+    ) {
+      if (details.assetCloseAmount) {
+        assetAmount = assetAmount.plus(details.assetCloseAmount);
+      }
+    }
+  }
+  return assetAmount;
+};
+
+const getOperationAmounts = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): { amount: BigNumber; rewards: BigNumber } => {
+  let amount = new BigNumber(0);
+  let rewards = new BigNumber(0);
+
+  if (transaction.senderAddress === accountAddress) {
+    const senderRewards = transaction.senderRewards;
+    amount = amount.minus(senderRewards).plus(transaction.fee);
+    rewards = rewards.plus(senderRewards);
+  }
+
+  if (transaction.type === AlgoTransactionType.PAYMENT) {
+    const details = transaction.details as AlgoPaymentInfo;
+    if (transaction.senderAddress == details.recipientAddress) {
+      return {
+        amount,
+        rewards,
+      };
+    }
+    if (transaction.senderAddress === accountAddress) {
+      amount = amount.plus(details.amount);
+    }
+    if (details.recipientAddress == accountAddress) {
+      const recipientRewards = transaction.recipientRewards;
+      amount = amount.plus(details.amount).plus(recipientRewards);
+      rewards = rewards.plus(recipientRewards);
+    }
+    if (
+      transaction.closeRewards &&
+      details.closeAmount &&
+      details.closeToAddress === accountAddress
+    ) {
+      const closeRewards = transaction.closeRewards;
+      amount = amount.plus(details.closeAmount).plus(closeRewards);
+      rewards = rewards.plus(closeRewards);
+    }
+  }
+
+  return {
+    amount,
+    rewards,
+  };
+};
+
+const getASAOperationType = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): OperationType => {
+  return transaction.senderAddress === accountAddress ? "OUT" : "IN";
+};
+
+const getOperationType = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): OperationType => {
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    if (
+      details.assetAmount.isZero() &&
+      transaction.senderAddress == details.assetRecipientAddress
+    ) {
+      return "OPT_IN";
+    } else if (
+      details.assetCloseToAddress &&
+      transaction.senderAddress == accountAddress
+    ) {
+      return "OPT_OUT";
+    } else {
+      return "FEES";
+    }
+  }
+
+  return transaction.senderAddress === accountAddress ? "OUT" : "IN";
+};
+
+const getOperationSenders = (transaction: AlgoTransaction): string[] => {
+  return [transaction.senderAddress];
+};
+
+const getOperationRecipients = (transaction: AlgoTransaction): string[] => {
+  const recipients: string[] = [];
+  if (transaction.type === AlgoTransactionType.PAYMENT) {
+    const details = transaction.details as AlgoPaymentInfo;
+    recipients.push(details.recipientAddress);
+    if (details.closeToAddress) {
+      recipients.push(details.closeToAddress);
+    }
+  } else if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+
+    recipients.push(details.assetRecipientAddress);
+    if (details.assetCloseToAddress) {
+      recipients.push(details.assetCloseToAddress);
+    }
+  }
+  return recipients;
+};
+
+const getOperationAssetId = (
+  transaction: AlgoTransaction
+): string | undefined => {
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    return details.assetId;
+  }
+};
+
+const mapTransactionToOperation = (
+  tx: AlgoTransaction,
+  accountId: string,
+  accountAddress: string,
+  subAccounts?: TokenAccount[]
+): Partial<Operation> => {
+  const hash = tx.id;
+  const blockHeight = tx.round;
+  const date = new Date(parseInt(tx.timestamp) * 1000);
+  const fee = tx.fee;
+  const memo = tx.note;
+  const senders: string[] = getOperationSenders(tx);
+  const recipients: string[] = getOperationRecipients(tx);
+  const { amount, rewards } = getOperationAmounts(tx, accountAddress);
+  const type = getOperationType(tx, accountAddress);
+  const assetId = getOperationAssetId(tx);
+
+  const subOperations = subAccounts
+    ? inferSubOperations(tx.id, subAccounts)
+    : undefined;
+
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    hash,
+    date,
+    type,
+    value: amount,
+    fee,
+    senders,
+    recipients,
+    blockHeight,
+    accountId,
+    subOperations,
+    extra: {
+      rewards,
+      memo,
+      assetId,
+    },
+  };
+};
+
+const mapTransactionToASAOperation = (
+  tx: AlgoTransaction,
+  accountId: string,
+  accountAddress: string
+): Partial<Operation> => {
+  const hash = tx.id;
+  const blockHeight = tx.round;
+  const date = new Date(parseInt(tx.timestamp) * 1000);
+  const fee = tx.fee;
+  const senders: string[] = getOperationSenders(tx);
+  const recipients: string[] = getOperationRecipients(tx);
+  const type = getASAOperationType(tx, accountAddress);
+  const amount = getASAOperationAmount(tx, accountAddress);
+
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    hash,
+    date,
+    type,
+    value: amount,
+    fee,
+    senders,
+    recipients,
+    blockHeight,
+    accountId,
+    extra: {},
+  };
+};
+
+export function makeGetAccountShape(algorandAPI: AlgorandAPI): GetAccountShape {
+  return async (info, syncConfig): Promise<Partial<Account>> => {
+    const { address, initialAccount, currency, derivationMode } = info;
+    const oldOperations = initialAccount?.operations || [];
+    const startAt = oldOperations.length
+      ? (oldOperations[0].blockHeight || 0) + 1
+      : 0;
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: address,
+      derivationMode,
+    });
+
+    const { round, balance, pendingRewards, assets } =
+      await algorandAPI.getAccount(address);
+
+    const nbAssets = assets.length;
+
+    // NOTE Actual spendable amount depends on the transaction
+    const spendableBalance = computeAlgoMaxSpendable({
+      accountBalance: balance,
+      nbAccountAssets: nbAssets,
+      mode: "send",
+    });
+
+    const newTransactions: AlgoTransaction[] =
+      await algorandAPI.getAccountTransactions(address, startAt);
+
+    const subAccounts = await buildSubAccounts({
+      currency,
+      accountId,
+      initialAccount,
+      initialAccountAddress: address,
+      assets,
+      newTransactions,
+      syncConfig,
+    });
+
+    const newOperations = newTransactions.map((tx) =>
+      mapTransactionToOperation(tx, accountId, address, subAccounts)
+    );
+
+    const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+    const shape = {
+      id: accountId,
+      xpub: address,
+      blockHeight: round,
+      balance,
+      spendableBalance,
+      operations,
+      operationsCount: operations.length,
+      subAccounts,
+      algorandResources: {
+        rewards: pendingRewards,
+        nbAssets,
+      },
+    };
+    return shape;
+  };
+}
+
+async function buildSubAccount({
+  parentAccountId,
+  parentAccountAddress,
+  token,
+  initialTokenAccount,
+  newTransactions,
+  balance,
+}: {
+  parentAccountId: string;
+  parentAccountAddress: string;
+  token: TokenCurrency;
+  initialTokenAccount: TokenAccount;
+  newTransactions: AlgoTransaction[];
+  balance: BigNumber;
+}) {
+  const extractedId = extractTokenId(token.id);
+  const tokenAccountId = parentAccountId + "+" + extractedId;
+
+  const oldOperations = initialTokenAccount?.operations || [];
+
+  const newOperations = newTransactions
+    .filter((tx) => tx.type === AlgoTransactionType.ASSET_TRANSFER)
+    .filter((tx) => {
+      const details = tx.details as AlgoAssetTransferInfo;
+      return Number(details.assetId) === Number(extractedId);
+    })
+    .filter((tx) => getOperationType(tx, parentAccountAddress) != "OPT_IN")
+    .map((tx) =>
+      mapTransactionToASAOperation(tx, tokenAccountId, parentAccountAddress)
+    );
+
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const tokenAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId: parentAccountId,
+    starred: false,
+    token,
+    operationsCount: operations.length,
+    operations,
+    pendingOperations: [],
+    balance,
+    spendableBalance: balance,
+    swapHistory: [],
+    creationDate:
+      operations.length > 0
+        ? operations[operations.length - 1].date
+        : new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+  };
+  return tokenAccount;
+}
+
+async function buildSubAccounts({
+  currency,
+  accountId,
+  initialAccount,
+  initialAccountAddress,
+  assets,
+  newTransactions,
+  syncConfig,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  initialAccount: Account | null | undefined;
+  initialAccountAddress: string;
+  assets: AlgoAsset[];
+  newTransactions: AlgoTransaction[];
+  syncConfig: SyncConfig;
+}): Promise<TokenAccount[] | undefined> {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  if (listTokensForCryptoCurrency(currency).length === 0) return undefined;
+  const tokenAccounts: TokenAccount[] = [];
+  const existingAccountByTicker: { [ticker: string]: TokenAccount } = {}; // used for fast lookup
+  const existingAccountTickers: string[] = []; // used to keep track of ordering
+
+  if (initialAccount && initialAccount.subAccounts) {
+    for (const existingSubAccount of initialAccount.subAccounts) {
+      if (existingSubAccount.type === "TokenAccount") {
+        const { ticker, id } = existingSubAccount.token;
+
+        if (!blacklistedTokenIds.includes(id)) {
+          existingAccountTickers.push(ticker);
+          existingAccountByTicker[ticker] = existingSubAccount;
+        }
+      }
+    }
+  }
+
+  // filter by token existence
+  await promiseAllBatched(3, assets, async (asset) => {
+    const token = findTokenById(addPrefixToken(asset.assetId));
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      const initialTokenAccount = existingAccountByTicker[token.ticker];
+      const tokenAccount = await buildSubAccount({
+        parentAccountId: accountId,
+        parentAccountAddress: initialAccountAddress,
+        initialTokenAccount,
+        token,
+        newTransactions,
+        balance: asset.balance,
+      });
+      if (tokenAccount) tokenAccounts.push(tokenAccount);
+    }
+  });
+  // Preserve order of tokenAccounts from the existing token accounts
+  tokenAccounts.sort((a, b) => {
+    const i = existingAccountTickers.indexOf(a.token.ticker);
+    const j = existingAccountTickers.indexOf(b.token.ticker);
+    if (i === j) return 0;
+    if (i < 0) return 1;
+    if (j < 0) return -1;
+    return i - j;
+  });
+  return tokenAccounts;
+}

package/src/logic.ts

@@ -0,0 +1,46 @@
+import { BigNumber } from "bignumber.js";
+import { AlgorandAPI } from "./api";
+import type { AlgorandOperationMode } from "./types";
+
+export const ALGORAND_MAX_MEMO_SIZE = 32;
+export const ALGORAND_MIN_ACCOUNT_BALANCE = 100000;
+
+export const recipientHasAsset =
+  (algorandAPI: AlgorandAPI) =>
+  async (recipientAddress: string, assetId: string): Promise<boolean> => {
+    const recipientAccount = await algorandAPI.getAccount(recipientAddress);
+    return recipientAccount.assets.map((a) => a.assetId).includes(assetId);
+  };
+
+export const isAmountValid =
+  (algorandAPI: AlgorandAPI) =>
+  async (recipientAddress: string, amount: BigNumber): Promise<boolean> => {
+    const recipientAccount = await algorandAPI.getAccount(recipientAddress);
+    return recipientAccount.balance.isZero()
+      ? amount.gte(ALGORAND_MIN_ACCOUNT_BALANCE)
+      : true;
+  };
+
+export const computeAlgoMaxSpendable = ({
+  accountBalance,
+  nbAccountAssets,
+  mode,
+}: {
+  accountBalance: BigNumber;
+  nbAccountAssets: number;
+  mode: AlgorandOperationMode;
+}): BigNumber => {
+  const minBalance = computeMinimumAlgoBalance(mode, nbAccountAssets);
+  const maxSpendable = accountBalance.minus(minBalance);
+  return maxSpendable.gte(0) ? maxSpendable : new BigNumber(0);
+};
+
+const computeMinimumAlgoBalance = (
+  mode: AlgorandOperationMode,
+  nbAccountAssets: number
+): BigNumber => {
+  const base = 100000; // 0.1 algo = 100000 malgo
+  const currentAssets = nbAccountAssets;
+  const newAsset = mode === "optIn" ? 1 : 0;
+  return new BigNumber(base * (1 + currentAssets + newAsset));
+};

package/src/mock.ts

@@ -0,0 +1,131 @@
+import { genAddress, genHex } from "@ledgerhq/coin-framework/mocks/helpers";
+import { Account, Operation, OperationType } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import Prando from "prando";
+import type { AlgorandAccount } from "./types";
+
+function setAlgorandResources(account: Account): Account {
+  /** format algorandResources given the new delegations */
+  (account as AlgorandAccount).algorandResources = {
+    rewards: account.balance.multipliedBy(0.01),
+    nbAssets: account.subAccounts?.length ?? 0,
+  };
+  return account;
+}
+
+function genBaseOperation(
+  account: Account,
+  rng: Prando,
+  type: OperationType,
+  index: number
+): Operation {
+  const { operations: ops } = account;
+  const address = genAddress(account.currency, rng);
+  const lastOp = ops[index];
+  const date = new Date(
+    (lastOp ? lastOp.date.valueOf() : Date.now()) -
+      rng.nextInt(0, 100000000 * rng.next() * rng.next())
+  );
+  const hash = genHex(64, rng);
+
+  /** generate given operation */
+  return {
+    id: String(`mock_op_${ops.length}_${type}_${account.id}`),
+    hash,
+    type,
+    value: new BigNumber(0),
+    fee: new BigNumber(0),
+    senders: [address],
+    recipients: [address],
+    blockHash: genHex(64, rng),
+    blockHeight:
+      account.blockHeight -
+      // FIXME: always the same, valueOf for arithmetics operation on date in typescript
+      Math.floor((Date.now().valueOf() - date.valueOf()) / 900000),
+    accountId: account.id,
+    date,
+    extra: {
+      rewards: new BigNumber(0),
+      memo: "memo",
+    },
+  };
+}
+
+function addOptIn(account: Account, rng: Prando): Account {
+  /** select position on the operation stack where we will insert the new claim rewards */
+  const opIndex = rng.next(0, 10);
+  const opt = genBaseOperation(account, rng, "OPT_IN", opIndex);
+  opt.extra = { ...opt.extra, rewards: new BigNumber(0), assetId: "Thether" };
+  account.operations.splice(opIndex, 0, opt);
+  account.operationsCount++;
+  return account;
+}
+
+function addOptOut(account: Account, rng: Prando): Account {
+  /** select position on the operation stack where we will insert the new claim rewards */
+  const opIndex = rng.next(0, 10);
+  const opt = genBaseOperation(account, rng, "OPT_OUT", opIndex);
+  opt.extra = { ...opt.extra, rewards: new BigNumber(0), assetId: "Thether" };
+  account.operations.splice(opIndex, 0, opt);
+  account.operationsCount++;
+  return account;
+}
+
+/**
+ * add in specific algorand operations
+ * @memberof algorand/mock
+ * @param {Account} account
+ * @param {Prando} rng
+ */
+function genAccountEnhanceOperations(account: Account, rng: Prando): Account {
+  addOptIn(account, rng);
+  addOptOut(account, rng);
+  setAlgorandResources(account);
+  return account;
+}
+
+/**
+ * Update spendable balance for the account based on delegation data
+ * @memberof algorand/mock
+ * @param {Account} account
+ */
+function postSyncAccount(account: Account): Account {
+  const algorandResources = (account as AlgorandAccount).algorandResources || {
+    rewards: undefined,
+  };
+  const rewards = algorandResources.rewards || new BigNumber(0);
+  account.spendableBalance = account.balance.plus(rewards);
+  return account;
+}
+
+/**
+ * post account scan data logic
+ * clears account algorand resources if supposed to be empty
+ * @memberof algorand/mock
+ * @param {AlgorandAccount} account
+ */
+function postScanAccount(
+  account: Account,
+  {
+    isEmpty,
+  }: {
+    isEmpty: boolean;
+  }
+): Account {
+  if (isEmpty) {
+    (account as AlgorandAccount).algorandResources = {
+      rewards: new BigNumber(0),
+      nbAssets: account.subAccounts?.length ?? 0,
+    };
+    account.operations = [];
+    account.subAccounts = [];
+  }
+
+  return account;
+}
+
+export default {
+  genAccountEnhanceOperations,
+  postSyncAccount,
+  postScanAccount,
+};

package/src/serialization.ts

@@ -0,0 +1,48 @@
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import type {
+  AlgorandAccount,
+  AlgorandAccountRaw,
+  AlgorandResources,
+  AlgorandResourcesRaw,
+} from "./types";
+
+function toResourcesRaw(r: AlgorandResources): AlgorandResourcesRaw {
+  const { rewards, nbAssets } = r;
+  return {
+    rewards: rewards.toString(),
+    nbAssets,
+  };
+}
+function fromResourcesRaw(r: AlgorandResourcesRaw): AlgorandResources {
+  const { rewards, nbAssets } = r;
+  return {
+    rewards: new BigNumber(rewards),
+    nbAssets,
+  };
+}
+
+export function assignToAccountRaw(
+  account: Account,
+  accountRaw: AccountRaw
+): void {
+  const algorandAccount = account as AlgorandAccount;
+  const algorandAccountRaw = accountRaw as AlgorandAccountRaw;
+  if (algorandAccount.algorandResources) {
+    algorandAccountRaw.algorandResources = toResourcesRaw(
+      algorandAccount.algorandResources
+    );
+  }
+}
+
+export function assignFromAccountRaw(
+  accountRaw: AccountRaw,
+  account: Account
+): void {
+  const algorandResourcesRaw = (accountRaw as AlgorandAccountRaw)
+    .algorandResources;
+  const algorandAccount = account as AlgorandAccount;
+  if (algorandResourcesRaw) {
+    algorandAccount.algorandResources = fromResourcesRaw(algorandResourcesRaw);
+  }
+}