@ledgerhq/live-common 25.2.0-next.0 → 25.2.0-next.1

package/src/families/osmosis/specs.ts

@@ -0,0 +1,393 @@
+import invariant from "invariant";
+import type { Transaction } from "./types";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
+import { pickSiblings } from "../../bot/specs";
+import type { AppSpec } from "../../bot/types";
+import { DeviceModelId } from "@ledgerhq/devices";
+import type {
+  CosmosAccount,
+  CosmosDelegation,
+  CosmosRedelegation,
+  CosmosResources,
+  CosmosUnbonding,
+} from "../cosmos/types";
+import { canClaimRewards, canUndelegate, canRedelegate } from "../cosmos/logic";
+import { canDelegate, getMaxDelegationAvailable } from "./logic";
+import { getCurrentOsmosisPreloadData } from "../osmosis/preloadedData";
+import sampleSize from "lodash/sampleSize";
+import sample from "lodash/sample";
+import expect from "expect";
+import { toOperationRaw } from "../../account";
+import { BigNumber } from "bignumber.js";
+
+const currency = getCryptoCurrencyById("osmosis");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.00001");
+const maxAccount = 3;
+// amounts of delegation are not exact so we are applying an approximation
+function approximateValue(value) {
+  return "~" + value.div(100).integerValue().times(100).toString();
+}
+
+function approximateExtra(extra) {
+  extra = { ...extra };
+  if (extra.validators && Array.isArray(extra.validators)) {
+    extra.validators = extra.validators.map((v) => {
+      if (!v) return v;
+      const { amount, ...rest } = v;
+      if (!amount || typeof amount !== "string") return v;
+      return { ...rest, amount: approximateValue(new BigNumber(amount)) };
+    });
+  }
+  return extra;
+}
+
+const osmosis: AppSpec<Transaction> = {
+  name: "Osmosis",
+  currency: getCryptoCurrencyById("osmosis"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Cosmos",
+  },
+  testTimeout: 2 * 60 * 1000,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+  },
+  test: ({ account, operation, optimisticOperation }) => {
+    const allOperationsMatchingId = account.operations.filter(
+      (op) => op.id === operation.id
+    );
+    if (allOperationsMatchingId.length > 1) {
+      console.warn(allOperationsMatchingId);
+    }
+    expect({ allOperationsMatchingId }).toEqual({
+      allOperationsMatchingId: [operation],
+    });
+    const opExpected: Record<string, any> = toOperationRaw({
+      ...optimisticOperation,
+    });
+    delete opExpected.value;
+    delete opExpected.fee;
+    delete opExpected.date;
+    delete opExpected.blockHash;
+    delete opExpected.blockHeight;
+    const extra = opExpected.extra;
+    delete opExpected.extra;
+    delete opExpected.transactionSequenceNumber;
+    const op = toOperationRaw(operation);
+    expect(op).toMatchObject(opExpected);
+    expect(approximateExtra(op.extra)).toMatchObject(approximateExtra(extra));
+  },
+  mutations: [
+    {
+      name: "move 50% to another account",
+      maxRun: 2,
+      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 },
+            Math.random() < 0.5
+              ? {
+                  memo: "LedgerLiveBot",
+                }
+              : null,
+          ],
+        };
+      },
+    },
+    {
+      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 },
+            Math.random() < 0.5
+              ? {
+                  memo: "LedgerLiveBot",
+                }
+              : null,
+          ],
+        };
+      },
+    },
+    {
+      name: "delegate new validators",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        invariant(
+          account.index % 2 > 0,
+          "only one out of 2 accounts is not going to delegate"
+        );
+        invariant(canDelegate(account), "can delegate");
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        invariant(
+          (cosmosResources as CosmosResources).delegations.length < 3,
+          "already enough delegations"
+        );
+        const data = getCurrentOsmosisPreloadData();
+        const count = 1; // number of delegations to perform in a single tx
+        let remaining = getMaxDelegationAvailable(account, count)
+          .minus(minimalAmount.times(2))
+          .times(0.5 * Math.random());
+        invariant(remaining.gt(0), "not enough funds in account for delegate");
+        const all = data.validators.filter(
+          (v) =>
+            !(cosmosResources as CosmosResources).delegations.some(
+              // new delegations only
+              (d) => d.validatorAddress === v.validatorAddress
+            )
+        );
+        const validators = sampleSize(all, count)
+          .map((delegation) => {
+            // take a bit of remaining each time (less is preferred with the random() square)
+            const amount = remaining
+              .times(Math.random() * Math.random())
+              .integerValue();
+            remaining = remaining.minus(amount);
+            return {
+              address: delegation.validatorAddress,
+              amount,
+            };
+          })
+          .filter((v) => v.amount.gt(0));
+        invariant(validators.length > 0, "no possible delegation found");
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              memo: "LedgerLiveBot",
+              mode: "delegate",
+            },
+            ...validators.map((_, i) => ({
+              validators: validators.slice(0, i + 1),
+            })),
+          ],
+        };
+      },
+      test: ({ account, transaction }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        transaction.validators.forEach((v) => {
+          const d = (cosmosResources as CosmosResources).delegations.find(
+            (d) => d.validatorAddress === v.address
+          );
+          invariant(d, "delegated %s must be found in account", v.address);
+          expect({
+            address: v.address,
+            amount: approximateValue(v.amount),
+          }).toMatchObject({
+            address: (d as CosmosDelegation).validatorAddress,
+            amount: approximateValue((d as CosmosDelegation).amount),
+          });
+        });
+      },
+    },
+    {
+      name: "undelegate",
+      maxRun: 3,
+      transaction: ({ account, bridge }) => {
+        invariant(canUndelegate(account as CosmosAccount), "can undelegate");
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        invariant(
+          (cosmosResources as CosmosResources).delegations.length > 0,
+          "already enough delegations"
+        );
+        const undelegateCandidate = sample(
+          (cosmosResources as CosmosResources).delegations.filter(
+            (d) =>
+              !(cosmosResources as CosmosResources).redelegations.some(
+                (r) =>
+                  r.validatorSrcAddress === d.validatorAddress ||
+                  r.validatorDstAddress === d.validatorAddress
+              ) &&
+              !(cosmosResources as CosmosResources).unbondings.some(
+                (r) => r.validatorAddress === d.validatorAddress
+              )
+          )
+        );
+        invariant(undelegateCandidate, "already pending");
+
+        const amount = (undelegateCandidate as CosmosDelegation).amount // most of the time, undelegate all
+          .times(Math.random() > 0.3 ? 1 : Math.random())
+          .integerValue();
+        invariant(amount.gt(0), "random amount to be positive");
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "undelegate",
+              memo: "LedgerLiveBot",
+            },
+            {
+              validators: [
+                {
+                  address: (undelegateCandidate as CosmosDelegation)
+                    .validatorAddress,
+                  amount,
+                },
+              ],
+            },
+          ],
+        };
+      },
+      test: ({ account, transaction }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        transaction.validators.forEach((v) => {
+          const d = (cosmosResources as CosmosResources).unbondings.find(
+            (d) => d.validatorAddress === v.address
+          );
+          invariant(d, "undelegated %s must be found in account", v.address);
+          expect({
+            address: v.address,
+            amount: approximateValue(v.amount),
+          }).toMatchObject({
+            address: (d as CosmosUnbonding).validatorAddress,
+            amount: approximateValue((d as CosmosUnbonding).amount),
+          });
+        });
+      },
+    },
+    {
+      name: "redelegate",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        const sourceDelegation = sample(
+          (cosmosResources as CosmosResources).delegations.filter((d) =>
+            canRedelegate(account as CosmosAccount, d)
+          )
+        );
+        invariant(sourceDelegation, "none can redelegate");
+        const delegation = sample(
+          (cosmosResources as CosmosResources).delegations.filter(
+            (d) =>
+              d.validatorAddress !==
+              (sourceDelegation as CosmosDelegation).validatorAddress
+          )
+        );
+        const amount = (sourceDelegation as CosmosDelegation).amount
+          .times(
+            // most of the time redelegate all
+            Math.random() > 0.3 ? 1 : Math.random()
+          )
+          .integerValue();
+        invariant(amount.gt(0), "random amount to be positive");
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "redelegate",
+              memo: "LedgerLiveBot",
+              sourceValidator: (sourceDelegation as CosmosDelegation)
+                .validatorAddress,
+              validators: [
+                {
+                  address: (delegation as CosmosDelegation).validatorAddress,
+                  amount,
+                },
+              ],
+            },
+          ],
+        };
+      },
+      test: ({ account, transaction }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        transaction.validators.forEach((v) => {
+          // we possibly are moving from one existing delegation to another existing.
+          // in that case it's not a redelegation, it effects immediately
+          const existing = (
+            cosmosResources as CosmosResources
+          ).delegations.find((d) => d.validatorAddress === v.address);
+          if (!existing) {
+            // in other case, we will find it in a redelegation
+            const d = (cosmosResources as CosmosResources).redelegations
+              .slice(0) // recent first
+              .sort(
+                // FIXME: valueOf for date arithmetic operations in typescript
+                (a, b) =>
+                  b.completionDate.valueOf() - a.completionDate.valueOf()
+              ) // find the related redelegation
+              .find(
+                (d) =>
+                  d.validatorDstAddress === v.address &&
+                  d.validatorSrcAddress === transaction.sourceValidator
+              );
+            invariant(d, "redelegated %s must be found in account", v.address);
+            expect({
+              address: v.address,
+              amount: approximateValue(v.amount),
+            }).toMatchObject({
+              address: (d as CosmosRedelegation).validatorDstAddress,
+              amount: approximateValue((d as CosmosRedelegation).amount),
+            });
+          }
+        });
+      },
+    },
+    {
+      name: "claim rewards",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        const delegation = sample(
+          (cosmosResources as CosmosResources).delegations.filter((d) =>
+            d.pendingRewards.gt(1000)
+          )
+        ) as CosmosDelegation;
+
+        invariant(delegation, "no delegation to claim");
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "claimReward",
+              memo: "LedgerLiveBot",
+              validators: [
+                {
+                  address: delegation.validatorAddress,
+                  amount: delegation.pendingRewards,
+                },
+              ],
+            },
+          ],
+        };
+      },
+      test: ({ account, transaction }) => {
+        const { cosmosResources } = account as CosmosAccount;
+        invariant(cosmosResources, "cosmos");
+        transaction.validators.forEach((v) => {
+          const d = (cosmosResources as CosmosResources).delegations.find(
+            (d) => d.validatorAddress === v.address
+          );
+          invariant(d, "delegation %s must be found in account", v.address);
+          invariant(
+            !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
+            "reward no longer be claimable"
+          );
+        });
+      },
+    },
+  ],
+};
+
+export default {
+  osmosis,
+};

package/src/families/osmosis/speculos-deviceActions.ts

@@ -0,0 +1,94 @@
+import type { DeviceAction } from "../../bot/types";
+import { deviceActionFlow } from "../../bot/specs";
+import type { Transaction } from "./types";
+const typeWording = {
+  send: "Send",
+  delegate: "Delegate",
+  redelegate: "Redelegate",
+  undelegate: "Undelegate",
+  claimReward: "Withdraw Reward",
+  claimRewardCompound: "(not tested)",
+};
+const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Sequence",
+      button: "Rr",
+    },
+    {
+      title: "Chain ID",
+      button: "Rr",
+    },
+    {
+      title: "Account",
+      button: "Rr",
+    },
+    {
+      title: "Type",
+      button: "Rr",
+      expectedValue: ({ transaction }) => typeWording[transaction.mode],
+    },
+    {
+      title: "Validator Source",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.sourceValidator || "",
+    },
+    {
+      title: "Validator Dest",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.validators[0].address,
+    },
+    {
+      title: "Validator",
+      button: "Rr",
+      expectedValue: ({ transaction }, acc) =>
+        transaction.validators[
+          acc.filter((a) => a.title === "Validator").length
+        ].address,
+    },
+    {
+      title: "Memo",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.memo || "",
+    },
+    {
+      title: "Fee",
+      button: "Rr",
+    },
+    {
+      title: "Gas",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.gas?.toString() || "",
+    },
+    {
+      title: "Amount",
+      button: "Rr",
+    },
+    {
+      title: "From",
+      button: "Rr",
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "To",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Delegator",
+      button: "Rr",
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "APPROVE",
+      button: "LRlr",
+      final: true,
+    },
+    {
+      title: "REJECT",
+    },
+  ],
+});
+export default {
+  acceptTransaction,
+};

package/src/families/osmosis/transaction.ts

@@ -0,0 +1,20 @@
+import {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+} from "../cosmos/transaction";
+
+import {
+  formatTransactionStatusCommon as formatTransactionStatus,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "../../transaction/common";
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/families/osmosis/types.ts

@@ -0,0 +1,48 @@
+import type { BigNumber } from "bignumber.js";
+import {
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import {
+  CosmosLikeTransaction,
+  CosmosLikeTransactionRaw,
+} from "../cosmos/types";
+import { CosmosDelegationInfo, CosmosDelegationInfoRaw } from "../cosmos/types";
+
+export type Transaction = CosmosLikeTransaction & {
+  family: "osmosis";
+  mode: string;
+  fees: BigNumber | null;
+  gas: BigNumber | null | undefined;
+  memo: string | null | undefined;
+  validators: CosmosDelegationInfo[];
+  sourceValidator: string | null | undefined;
+};
+
+export type TransactionRaw = CosmosLikeTransactionRaw & {
+  family: "osmosis";
+  mode: string;
+  fees: string | null;
+  gas: string | null | undefined;
+  memo: string | null | undefined;
+  validators: CosmosDelegationInfoRaw[];
+  sourceValidator: string | null | undefined;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type OsmosisRewardsState = {
+  targetBondedRatio: number;
+  communityPoolCommission: number;
+  assumedTimePerBlock: number;
+  inflationRateChange: number;
+  inflationMaxRate: number;
+  inflationMinRate: number;
+  actualBondedRatio: number;
+  averageTimePerBlock: number;
+  totalSupply: number;
+  averageDailyFees: number;
+  currentValueInflation: number;
+};

package/src/families/osmosis/utils.ts

@@ -0,0 +1,31 @@
+import { decode } from "bech32";
+
+// Address validation freely inspired from
+// https://github.com/terra-money/terra.js/blob/9e5f553de3ff3e975eaaf91b1f06e45658b1a5e0/src/core/bech32.ts
+function checkPrefixAndLength(
+  prefix: string,
+  data: string,
+  length: number
+): boolean {
+  try {
+    const vals = decode(data);
+    return vals.prefix === prefix && data.length == length;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Checks if a string is a valid Osmosis account address.
+ *
+ * @param addr string to check
+ */
+export function isValidAddress(currencyPrefix: string, addr: string): boolean {
+  return checkPrefixAndLength(currencyPrefix, addr, 43);
+}
+
+// export const FIGMENT_OSMOSIS_VALIDATOR_ADDRESS =
+//   "osmovaloper1hjct6q7npsspsg3dgvzk3sdf89spmlpf6t4agt";
+
+export const LEDGER_OSMOSIS_VALIDATOR_ADDRESS =
+  "osmovaloper17cp6fxccqxrpj4zc00w2c7u6y0umc2jajsyc5t";

package/src/families/osmosis/validators.ts

@@ -0,0 +1,79 @@
+import { getCryptoCurrencyById } from "../../currencies";
+import { CosmosValidatorsManager } from "../cosmos/CosmosValidatorsManager";
+import { nodeEndpoint } from "./api/sdk";
+import { osmosisAPI } from "./api/sdk";
+import {
+  OsmosisDistributionParams,
+  OsmosisPool,
+  OsmosisTotalSupply,
+} from "./OsmosisSupplyTypes";
+import { OsmosisRewardsState } from "./types";
+
+const osmosisCryptoCurrency = getCryptoCurrencyById("osmo");
+
+// TODO Refactor this to be a class so that we don't have to query the API multiple times
+const getRewardsState = async (): Promise<OsmosisRewardsState> => {
+  const distributionParams = await _getDistributionParams();
+  const supply = await _getTotalSupply();
+  const totalSupply = parseUOsmoStrAsOsmoNumber(supply.amount);
+  const pool = await _getPool();
+
+  const actualBondedRatio =
+    parseUOsmoStrAsOsmoNumber(pool.bonded_tokens) / totalSupply;
+  const communityPoolCommission = parseFloat(distributionParams.community_tax);
+
+  // Hardcoded mock values
+  const targetBondedRatio = 0.1;
+  const assumedTimePerBlock = 7;
+  const inflationRateChange = 0.01;
+  const inflationMaxRate = 0.01;
+  const inflationMinRate = 0.01;
+  const averageTimePerBlock = 7;
+  const averageDailyFees = 0;
+  const currentValueInflation = 0.01;
+
+  return {
+    targetBondedRatio,
+    communityPoolCommission,
+    assumedTimePerBlock,
+    inflationRateChange,
+    inflationMaxRate,
+    inflationMinRate,
+    actualBondedRatio,
+    averageTimePerBlock,
+    totalSupply,
+    averageDailyFees,
+    currentValueInflation,
+  };
+};
+
+const _getTotalSupply = async (): Promise<OsmosisTotalSupply> => {
+  const denom = osmosisCryptoCurrency.units[1].code;
+  const totalSupply = await osmosisAPI.queryTotalSupply(denom);
+  return totalSupply;
+};
+
+const _getPool = async (): Promise<OsmosisPool> => {
+  const pool = await osmosisAPI.queryPool();
+  return pool;
+};
+
+const _getDistributionParams = async (): Promise<OsmosisDistributionParams> => {
+  const distributionParams = await osmosisAPI.queryDistributionParams();
+  return distributionParams;
+};
+
+const parseUOsmoStrAsOsmoNumber = (uosmos: string) => {
+  return parseFloat(uosmos) / 1000000.0;
+};
+
+const osmosisValidatorsManager = new CosmosValidatorsManager(
+  osmosisCryptoCurrency,
+  {
+    endPoint: nodeEndpoint,
+    namespace: "osmosis",
+    rewardsState: async () => getRewardsState(),
+  }
+);
+
+export default osmosisValidatorsManager;

package/src/featureFlags/defaultFeatures.ts

@@ -14,6 +14,9 @@ export const defaultFeatures: DefaultFeatures = {
       debug: false,
     },
   },
+  currencyOsmosis: {
+    enabled: false,
+  },
   ratings: {
     enabled: false,
     params: {

package/src/generated/account.ts

@@ -10,6 +10,8 @@ import elrond from "../families/elrond/account";
 
 import filecoin from "../families/filecoin/account";
 
+import osmosis from "../families/osmosis/account";
+
 import polkadot from "../families/polkadot/account";
 
 
@@ -20,5 +22,6 @@ export default {
   crypto_org,
   elrond,
   filecoin,
+  osmosis,
   polkadot,
 };