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

package/src/families/osmosis/js-getFeesForTransaction.ts

@@ -0,0 +1,44 @@
+import { BigNumber } from "bignumber.js";
+import { CosmosOperationMode } from "../cosmos/types";
+
+const gasForTransaction: {
+  [Key in CosmosOperationMode]: number;
+} = {
+  send: 100000,
+  delegate: 300000,
+  undelegate: 350000,
+  redelegate: 550000,
+  claimReward: 300000,
+  claimRewardCompound: 400000,
+};
+
+// Default fees in uosmo
+// Dear future developer working on this file, if fees become non-zero
+// make sure to flip estimatedFees.isZero() to !estimatedFees.isZero() in
+// './deviceTransactionConfig.ts'.
+export const DEFAULT_FEES = 0;
+export const MIN_GAS_FEE = 0.0025; // Min gas fee in uosmo (https://commonwealth.im/osmosis/discussion/6298-draft-minimum-gas-fee)
+export const DEFAULT_GAS = 100000;
+
+/**
+ * Fetch the transaction fees for a transaction
+ */
+const getEstimatedFees = async (mode: string): Promise<BigNumber> => {
+  const gas = await getEstimatedGas(mode as CosmosOperationMode);
+  return gas.times(MIN_GAS_FEE);
+};
+
+/**
+ * Fetch the gas for a transaction
+ */
+export const getEstimatedGas = async (
+  mode: CosmosOperationMode
+): Promise<BigNumber> => {
+  const estimatedGas = gasForTransaction[mode];
+  if (!estimatedGas) {
+    return new BigNumber(DEFAULT_GAS);
+  }
+  return new BigNumber(estimatedGas);
+};
+
+export default getEstimatedFees;

package/src/families/osmosis/js-getTransactionStatus.ts

@@ -0,0 +1,9 @@
+import { CosmosTransactionStatusManager } from "../cosmos/js-getTransactionStatus";
+import { osmosisAPI } from "./api/sdk";
+
+const osmosisTransactionStatusManager = new CosmosTransactionStatusManager({
+  api: osmosisAPI,
+  validatorOperatorAddressPrefix: "osmovaloper",
+});
+
+export default osmosisTransactionStatusManager.getTransactionStatus;

package/src/families/osmosis/js-signOperation.ts

@@ -0,0 +1,172 @@
+import type {
+  Account,
+  DeviceId,
+  Operation,
+  OperationType,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import { osmosisAPI } from "./api/sdk";
+import { Observable } from "rxjs";
+import { withDevice } from "../../hw/deviceAccess";
+import { encodeOperationId } from "../../operation";
+import { LedgerSigner } from "@cosmjs/ledger-amino";
+import { HdPath, stringToPath } from "@cosmjs/crypto";
+import { buildTransaction, postBuildTransaction } from "./js-buildTransaction";
+import BigNumber from "bignumber.js";
+import { makeSignDoc } from "@cosmjs/launchpad";
+import getEstimatedFees, {
+  DEFAULT_FEES,
+  getEstimatedGas,
+} from "./js-getFeesForTransaction";
+
+const signOperation = ({
+  account,
+  deviceId,
+  transaction,
+}: {
+  account: Account;
+  deviceId: DeviceId;
+  transaction: Transaction;
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      let cancelled;
+
+      async function main() {
+        const { accountNumber, sequence } = await osmosisAPI.getAccount(
+          account.freshAddress
+        );
+        const chainId = await osmosisAPI.getChainId();
+        const hdPaths: HdPath = stringToPath("m/" + account.freshAddressPath);
+        const ledgerSigner = new LedgerSigner(transport, {
+          hdPaths: [hdPaths],
+          prefix: account.currency.id,
+        });
+        o.next({ type: "device-signature-requested" });
+
+        const { aminoMsgs, protoMsgs } = await buildTransaction(
+          account,
+          transaction
+        );
+
+        if (aminoMsgs.length === 0 || protoMsgs.length === 0) {
+          return;
+        }
+
+        const feeToEncode = {
+          amount: [
+            {
+              denom: account.currency.units[1].code,
+              amount: transaction.fees
+                ? (transaction.fees.toNumber().toString() as string)
+                : (String(await getEstimatedFees(transaction.mode)) as string),
+            },
+          ],
+          gas: transaction.gas
+            ? (transaction.gas.toString() as string)
+            : (String(await getEstimatedGas(transaction.mode)) as string),
+        };
+
+        const signDoc = makeSignDoc(
+          aminoMsgs,
+          feeToEncode,
+          chainId,
+          transaction.memo || "",
+          accountNumber.toString(),
+          sequence.toString()
+        );
+
+        const signResponse = await ledgerSigner.signAmino(
+          account.freshAddress,
+          signDoc
+        );
+
+        const signed_tx_bytes = await postBuildTransaction(
+          signResponse,
+          protoMsgs
+        );
+
+        const signature = Buffer.from(signed_tx_bytes).toString("hex");
+
+        if (cancelled) {
+          return;
+        }
+
+        o.next({ type: "device-signature-granted" });
+
+        const hash = ""; // resolved at broadcast time
+        const accountId = account.id;
+
+        const fee = transaction.fees || new BigNumber(DEFAULT_FEES);
+        const extra = { memo: transaction.memo || {} };
+        const type: OperationType =
+          transaction.mode === "undelegate"
+            ? "UNDELEGATE"
+            : transaction.mode === "delegate"
+            ? "DELEGATE"
+            : transaction.mode === "redelegate"
+            ? "REDELEGATE"
+            : ["claimReward", "claimRewardCompound"].includes(transaction.mode)
+            ? "REWARD"
+            : "OUT";
+
+        const senders: string[] = [];
+        const recipients: string[] = [];
+
+        if (transaction.mode === "send") {
+          senders.push(account.freshAddress);
+          recipients.push(transaction.recipient);
+        }
+
+        if (transaction.mode === "redelegate") {
+          Object.assign(extra, {
+            sourceValidator: transaction.sourceValidator,
+          });
+        }
+
+        if (transaction.mode !== "send") {
+          Object.assign(extra, {
+            validators: transaction.validators,
+          });
+        }
+
+        // build optimistic operation
+        const operation: Operation = {
+          id: encodeOperationId(accountId, hash, type),
+          hash,
+          type,
+          value: transaction.amount, // Note: prepareTransaction already takes care of setting the correct tx amount (w/ fees) if useAllAmount is selected
+          fee,
+          extra,
+          blockHash: null,
+          blockHeight: null,
+          senders,
+          recipients,
+          accountId,
+          date: new Date(),
+          transactionSequenceNumber: sequence,
+        };
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+            expirationDate: null,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    })
+  );
+
+export default signOperation;

package/src/families/osmosis/js-synchronization.ts

@@ -0,0 +1,122 @@
+import { pubkeyToAddress, decodeBech32Pubkey } from "@cosmjs/amino";
+import { BigNumber } from "bignumber.js";
+import { encodeAccountId } from "../../account";
+import {
+  makeSync,
+  makeScanAccounts,
+  GetAccountShape,
+  mergeOps,
+} from "../../bridge/jsHelpers";
+import { osmosisAPI } from "./api/sdk";
+
+const accountPubPrefix = "osmopub";
+const accountAddressPrefix = "osmo";
+
+const getAccountShape: GetAccountShape = async (info) => {
+  const { address, currency, derivationMode, initialAccount } = info;
+  let xpubOrAddress = address;
+
+  if (address.match(accountPubPrefix)) {
+    const pubkey = decodeBech32Pubkey(address);
+    xpubOrAddress = pubkeyToAddress(pubkey as any, accountAddressPrefix);
+  }
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress,
+    derivationMode,
+  });
+
+  const {
+    balances,
+    blockHeight,
+    delegations,
+    redelegations,
+    unbondings,
+    withdrawAddress,
+  } = await osmosisAPI.getAccountInfo(xpubOrAddress, currency);
+
+  const oldOperations = initialAccount?.operations || [];
+
+  let operations = oldOperations;
+
+  // For indexer efficiency reasons, only fetch new operations starting from the datetime
+  // of the last operation previously fetched
+  let lastOperationDate: Date | null = null;
+  if (operations.length > 0) {
+    operations.forEach((o) => {
+      if (o.date != null) {
+        if (lastOperationDate !== null) {
+          if (o.date.valueOf() > lastOperationDate.valueOf()) {
+            lastOperationDate = o.date;
+          }
+        } else {
+          lastOperationDate = o.date;
+        }
+      }
+    });
+  }
+
+  const newOperations = await osmosisAPI.getOperations(
+    accountId,
+    address,
+    lastOperationDate
+  );
+
+  // Merge new operations with the previously synced ones
+  operations = mergeOps(operations, newOperations);
+
+  let balance = balances;
+  let delegatedBalance = new BigNumber(0);
+  let pendingRewardsBalance = new BigNumber(0);
+  let unbondingBalance = new BigNumber(0);
+
+  for (const delegation of delegations) {
+    delegatedBalance = delegatedBalance.plus(delegation.amount);
+    balance = balance.plus(delegation.amount);
+
+    pendingRewardsBalance = pendingRewardsBalance.plus(
+      delegation.pendingRewards
+    );
+  }
+
+  for (const unbonding of unbondings) {
+    unbondingBalance = unbondingBalance.plus(unbonding.amount);
+    balance = balance.plus(unbonding.amount);
+  }
+
+  let spendableBalance = balance.minus(unbondingBalance.plus(delegatedBalance));
+
+  if (spendableBalance.lt(0)) {
+    spendableBalance = new BigNumber(0);
+  }
+
+  const shape = {
+    id: accountId,
+    xpub: xpubOrAddress,
+    balance: balance,
+    spendableBalance,
+    operationsCount: operations.length,
+    blockHeight,
+    cosmosResources: {
+      delegations,
+      redelegations,
+      unbondings,
+      delegatedBalance,
+      pendingRewardsBalance,
+      unbondingBalance,
+      withdrawAddress,
+    },
+  };
+
+  if (shape.spendableBalance && shape.spendableBalance.lt(0)) {
+    shape.spendableBalance = new BigNumber(0);
+  }
+
+  return { ...shape, operations };
+};
+
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/osmosis/js-transaction.ts

@@ -0,0 +1,96 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import getEstimatedFees, { getEstimatedGas } from "./js-getFeesForTransaction";
+import estimateMaxSpendable from "./js-estimateMaxSpendable";
+import { CosmosDelegationInfo } from "../cosmos/types";
+
+const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction = (): Transaction => ({
+  family: "osmosis",
+  mode: "send",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: null,
+  gas: null,
+  memo: null,
+  validators: [] as CosmosDelegationInfo[],
+  sourceValidator: null,
+  networkInfo: {
+    family: "osmosis",
+    fees: new BigNumber(0),
+  },
+});
+
+/**
+ * Apply patch to transaction
+ *
+ * @param {*} t
+ * @param {*} patch
+ */
+export const updateTransaction = (
+  t: Transaction,
+  patch: Partial<Transaction>
+): Transaction => {
+  if ("mode" in patch && patch.mode !== t.mode) {
+    return { ...t, ...patch, gas: null, fees: null };
+  }
+  if (
+    "validators" in patch &&
+    patch.validators?.length !== t.validators.length
+  ) {
+    return { ...t, ...patch, gas: null, fees: null };
+  }
+  return { ...t, ...patch };
+};
+
+/**
+ * Prepare transaction before checking status
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ */
+export const prepareTransaction = async (account: Account, t: Transaction) => {
+  let { fees, memo, gas, amount } = t;
+  const { mode } = t;
+
+  fees = await getEstimatedFees(mode);
+  gas = await getEstimatedGas(mode);
+
+  if (mode === "send") {
+    t.amount = t.useAllAmount
+      ? await estimateMaxSpendable({ account, parentAccount: null, mode })
+      : amount;
+  }
+
+  if (mode !== "send" && !memo) {
+    memo = "Ledger Live";
+  }
+
+  if (t.useAllAmount) {
+    amount = await estimateMaxSpendable({ account, parentAccount: null, mode });
+    t = { ...t, amount, fees, gas };
+  }
+
+  if ((mode === "delegate" || mode === "claimRewardCompound") && amount.eq(0)) {
+    const validatorAmount = t.validators.reduce(
+      (old, current) => old.plus(current.amount),
+      new BigNumber(0)
+    );
+    amount = validatorAmount;
+    t = { ...t, amount, fees, gas };
+  }
+
+  if (t.memo !== memo || !sameFees(t.fees, fees)) {
+    return { ...t, memo, fees, gas };
+  }
+
+  return t;
+};

package/src/families/osmosis/logic.ts

@@ -0,0 +1,26 @@
+import type { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { COSMOS_MAX_DELEGATIONS } from "../cosmos/logic";
+import { DEFAULT_GAS, MIN_GAS_FEE } from "./js-getFeesForTransaction";
+
+const OSMOSIS_MIN_SAFE = new BigNumber(10000); // 10000 uosmo, setting a reasonable floor
+const OSMOSIS_MIN_FEES = new BigNumber(MIN_GAS_FEE * DEFAULT_GAS);
+
+export function canDelegate(account: Account): boolean {
+  const maxSpendableBalance = getMaxDelegationAvailable(account, 1);
+  return maxSpendableBalance.gt(0);
+}
+
+export function getMaxDelegationAvailable(
+  account: Account,
+  validatorsLength: number
+): BigNumber {
+  const numberOfDelegations = Math.min(
+    COSMOS_MAX_DELEGATIONS,
+    validatorsLength || 1
+  );
+  const { spendableBalance } = account;
+  return spendableBalance
+    .minus(OSMOSIS_MIN_FEES.multipliedBy(numberOfDelegations))
+    .minus(OSMOSIS_MIN_SAFE);
+}

package/src/families/osmosis/preloadedData.ts

@@ -0,0 +1,32 @@
+import { Observable, Subject } from "rxjs";
+import type { CosmosPreloadData, CosmosValidatorItem } from "../cosmos/types";
+import { asSafeCosmosPreloadData } from "../cosmos/preloadedData";
+
+// this module holds the cached state of preload()
+// eslint-disable-next-line no-unused-vars
+let currentOsmosisPreloadedData: CosmosPreloadData = {
+  // NB initial state because UI need to work even if it's currently "loading", typically after clear cache
+  validators: [],
+};
+
+const updates = new Subject<CosmosPreloadData>();
+
+export function setOsmosisPreloadData(data: CosmosPreloadData): void {
+  if (data === currentOsmosisPreloadedData) return;
+  currentOsmosisPreloadedData = data;
+  updates.next(data);
+}
+
+export function getCurrentOsmosisPreloadData(): CosmosPreloadData {
+  return currentOsmosisPreloadedData;
+}
+
+export function getOsmosisPreloadDataUpdates(): Observable<CosmosPreloadData> {
+  return updates.asObservable();
+}
+
+export function asSafeOsmosisPreloadData(data?: {
+  validators?: CosmosValidatorItem[];
+}): CosmosPreloadData {
+  return asSafeCosmosPreloadData(data);
+}

package/src/families/osmosis/serialization.ts

@@ -0,0 +1,6 @@
+import {
+  toCosmosResourcesRaw,
+  fromCosmosResourcesRaw,
+} from "../cosmos/serialization";
+
+export default { toCosmosResourcesRaw, fromCosmosResourcesRaw };