@ledgerhq/live-common 25.2.0-next.0 → 26.0.0-next.2

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

@@ -0,0 +1,145 @@
+import { from, Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import zipWith from "lodash/zipWith";
+import { BigNumber } from "bignumber.js";
+import osmosisValidatorsManager from "./validators";
+
+import type { Transaction } from "../../generated/types";
+import type {
+  Account,
+  AccountLike,
+  AccountLikeArray,
+} from "@ledgerhq/types-live";
+import { CosmosDelegationInfo } from "../cosmos/types";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, delegate, undelegate",
+  },
+  {
+    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: "add a memo to a transaction",
+  },
+  {
+    name: "sourceValidator",
+    type: String,
+    desc: "for redelegate, add a source validator",
+  },
+  {
+    name: "osmosisValidator",
+    type: String,
+    multiple: true,
+    desc: "address of recipient validator that will receive the delegate",
+  },
+  {
+    name: "osmosisAmountValidator",
+    type: String,
+    multiple: true,
+    desc: "Amount that the validator will receive",
+  },
+];
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "osmosis", "osmosis family");
+
+  const accounts: Account[] = [account];
+  return accounts;
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>,
+  opts: Record<string, any>,
+  { inferAmount }: any
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "osmosis", "osmosis family");
+    const validatorsAddresses: string[] = opts["osmosisValidator"] || [];
+
+    const validatorsAmounts: BigNumber[] = (
+      opts["osmosisAmountValidator"] || []
+    ).map((value) => {
+      return inferAmount(account, value);
+    });
+    const validators: CosmosDelegationInfo[] = zipWith(
+      validatorsAddresses,
+      validatorsAmounts,
+      (address, amount) => ({
+        address,
+        amount: amount || new BigNumber(0),
+      })
+    );
+
+    return {
+      ...transaction,
+      family: "osmosis",
+      mode: opts.mode || "send",
+      fees: opts.fees ? inferAmount(account, opts.fees) : null,
+      gas: opts.gasLimit ? new BigNumber(opts.gasLimit) : null,
+      memo: opts.memo,
+      validators: validators,
+      sourceValidator: opts.sourceValidator,
+    } as Transaction;
+  });
+}
+
+const osmosisValidatorsFormatters = {
+  json: (list) => JSON.stringify(list),
+  default: (list) =>
+    list
+      .map(
+        (v) =>
+          `${v.validatorAddress} "${v.name}" ${v.votingPower} ${v.commission} ${v.estimatedYearlyRewardsRate}`
+      )
+      .join("\n"),
+};
+
+const osmosisValidators = {
+  args: [
+    {
+      name: "format",
+      desc: Object.keys(osmosisValidatorsFormatters).join(" | "),
+      type: String,
+    },
+  ],
+  job: ({
+    format,
+  }: Partial<{
+    format: string;
+  }>): Observable<string> =>
+    from(osmosisValidatorsManager.getValidators()).pipe(
+      map((validators) => {
+        const f =
+          (format && osmosisValidatorsFormatters[format]) ||
+          osmosisValidatorsFormatters.default;
+        return f(validators);
+      })
+    ),
+};
+
+export default {
+  options,
+  inferAccounts,
+  inferTransactions,
+  commands: {
+    osmosisValidators,
+  },
+};

package/src/families/osmosis/deviceTransactionConfig.ts

@@ -0,0 +1,174 @@
+import type { AccountLike } from "@ledgerhq/types-live";
+import type { DeviceTransactionField } from "../../transaction";
+import type { TransactionStatus } from "./types";
+import { Transaction } from "./types";
+
+export type ExtraDeviceTransactionField =
+  | {
+      type: "cosmos.delegateValidators";
+      label: string;
+    }
+  | {
+      type: "cosmos.validatorName";
+      label: string;
+    }
+  | {
+      type: "cosmos.sourceValidatorName";
+      label: string;
+    }
+  | {
+      type: "osmosis.extendedAmount";
+      label: string;
+      value?: string;
+    };
+
+function getDeviceTransactionConfig({
+  transaction,
+  status: { estimatedFees, totalSpent },
+}: {
+  account: AccountLike;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const { mode, memo, validators } = transaction;
+  const fields: Array<DeviceTransactionField> = [];
+
+  switch (mode) {
+    case "send":
+      fields.push({
+        type: "osmosis.extendedAmount",
+        label: "Amount",
+      });
+      break;
+
+    case "delegate":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Delegate",
+      });
+
+      fields.push({
+        type: "cosmos.delegateValidators",
+        label: "Validators",
+      });
+      break;
+
+    case "undelegate":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Undelegate",
+      });
+
+      fields.push({
+        type: "osmosis.extendedAmount",
+        label: "Amount",
+        value: validators[0].amount.toString(),
+      });
+      fields.push({
+        type: "cosmos.validatorName",
+        label: "Validator",
+      });
+      break;
+
+    case "redelegate":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Redelegate",
+      });
+
+      fields.push({
+        type: "osmosis.extendedAmount",
+        label: "Amount",
+        value: validators[0].amount.toString(),
+      });
+
+      fields.push({
+        type: "cosmos.validatorName",
+        label: "Validator Dest",
+      });
+
+      fields.push({
+        type: "cosmos.sourceValidatorName",
+        label: "Validator Source",
+      });
+      break;
+
+    case "claimReward":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Withdraw Reward",
+      });
+      fields.push({
+        type: "cosmos.validatorName",
+        label: "Validator",
+      });
+      break;
+
+    case "claimRewardCompound":
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Withdraw Reward",
+      });
+      fields.push({
+        type: "cosmos.validatorName",
+        label: "Validator",
+      });
+      fields.push({
+        type: "text",
+        label: "Type",
+        value: "Delegate",
+      });
+      fields.push({
+        type: "cosmos.delegateValidators",
+        label: "Validators",
+      });
+      break;
+
+    default:
+      break;
+  }
+
+  if (!estimatedFees.isNaN() && !estimatedFees.isZero()) {
+    fields.push({
+      type: "osmosis.extendedAmount",
+      label: "Fee",
+      value: estimatedFees.toString(),
+    });
+  }
+
+  if (memo) {
+    fields.push({
+      type: "text",
+      label: "Memo",
+      value: memo,
+    });
+  }
+
+  if (mode === "claimReward" || mode === "claimRewardCompound") {
+    let label = "Amount to be received";
+    label += mode === "claimRewardCompound" ? " and delegated" : "";
+    fields.push({
+      type: "osmosis.extendedAmount",
+      label: label,
+      value: validators[0].amount.toString(),
+    });
+    validators[0].amount;
+  } else if (mode === "undelegate" || mode === "redelegate") {
+    return fields;
+  } else {
+    fields.push({
+      type: "osmosis.extendedAmount",
+      label: "Total",
+      value: totalSpent.toString(),
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/osmosis/errors.ts

@@ -0,0 +1,13 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const OsmosisWrongSignatureHeader = createCustomErrorClass(
+  "OsmosisWrongSignatureHeader"
+);
+
+export const OsmosisSignatureSize = createCustomErrorClass(
+  "OsmosisSignatureSize"
+);
+
+export const OsmosisErrorBroadcasting = createCustomErrorClass(
+  "OsmosisErrorBroadcasting"
+);

package/src/families/osmosis/hw-getAddress.ts

@@ -0,0 +1,14 @@
+import Cosmos from "@ledgerhq/hw-app-cosmos";
+import type { Resolver } from "../../hw/getAddress/types";
+
+const resolver: Resolver = async (transport, { path, verify, currency }) => {
+  const cosmos = new Cosmos(transport);
+  const r = await cosmos.getAddress(path, currency.id, verify || false);
+  return {
+    address: r.address,
+    publicKey: r.publicKey,
+    path,
+  };
+};
+
+export default resolver;

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

@@ -0,0 +1,306 @@
+import type { Account } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
+import { cosmos } from "@keplr-wallet/cosmos";
+import { AminoMsg, AminoSignResponse } from "@cosmjs/amino";
+import {
+  MsgBeginRedelegate,
+  MsgDelegate,
+  MsgUndelegate,
+} from "cosmjs-types/cosmos/staking/v1beta1/tx";
+import {
+  AminoMsgSend,
+  AminoMsgDelegate,
+  AminoMsgUndelegate,
+  AminoMsgBeginRedelegate,
+  AminoMsgWithdrawDelegatorReward,
+} from "@cosmjs/stargate";
+import Long from "long";
+import { Coin } from "@keplr-wallet/proto-types/cosmos/base/v1beta1/coin";
+import { PubKey } from "@keplr-wallet/proto-types/cosmos/crypto/secp256k1/keys";
+import {
+  AuthInfo,
+  TxRaw,
+  Fee,
+} from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
+import { TxBody } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { MsgWithdrawDelegatorReward } from "cosmjs-types/cosmos/distribution/v1beta1/tx";
+
+type ProtoMsg = {
+  typeUrl: string;
+  value: Uint8Array;
+};
+
+export const buildTransaction = async (
+  account: Account,
+  transaction: Transaction
+): Promise<{ aminoMsgs: AminoMsg[]; protoMsgs: ProtoMsg[] }> => {
+  const aminoMsgs: Array<AminoMsg> = [];
+  const protoMsgs: Array<ProtoMsg> = [];
+
+  switch (transaction.mode) {
+    case "send":
+      if (transaction.recipient && transaction.amount.gt(0)) {
+        const aminoMsg: AminoMsgSend = {
+          type: "cosmos-sdk/MsgSend",
+          value: {
+            from_address: account.freshAddress,
+            to_address: transaction.recipient,
+            amount: [
+              {
+                denom: account.currency.units[1].code,
+                amount: transaction.amount.toString(),
+              },
+            ],
+          },
+        };
+        aminoMsgs.push(aminoMsg);
+
+        // PROTO MESSAGE
+        protoMsgs.push({
+          typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+          value: cosmos.bank.v1beta1.MsgSend.encode({
+            fromAddress: account.freshAddress,
+            toAddress: transaction.recipient,
+            amount: [
+              {
+                denom: account.currency.units[1].code,
+                amount: transaction.amount.toString(),
+              },
+            ],
+          }).finish(),
+        });
+      }
+      break;
+    case "delegate":
+      if (transaction.validators && transaction.validators.length > 0) {
+        const validator = transaction.validators[0];
+        if (validator && validator.address && transaction.amount.gt(0)) {
+          //todo this should not be gt0, but the minimum required by osmosis to stake
+          const aminoMsg: AminoMsgDelegate = {
+            type: "cosmos-sdk/MsgDelegate",
+            value: {
+              delegator_address: account.freshAddress,
+              validator_address: validator.address,
+              amount: {
+                denom: account.currency.units[1].code,
+                amount: transaction.amount.toString(),
+              },
+            },
+          };
+          aminoMsgs.push(aminoMsg);
+
+          // PROTO MESSAGE
+          protoMsgs.push({
+            typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+            value: MsgDelegate.encode({
+              delegatorAddress: account.freshAddress,
+              validatorAddress: validator.address,
+              amount: {
+                denom: account.currency.units[1].code,
+                amount: transaction.amount.toString(),
+              },
+            }).finish(),
+          });
+        }
+      }
+      break;
+
+    case "redelegate":
+      if (
+        transaction.sourceValidator &&
+        transaction.validators &&
+        transaction.validators.length > 0 &&
+        transaction.validators[0].address &&
+        transaction.validators[0].amount.gt(0)
+      ) {
+        const validator = transaction.validators[0];
+        const aminoMsg: AminoMsgBeginRedelegate = {
+          type: "cosmos-sdk/MsgBeginRedelegate",
+          value: {
+            delegator_address: account.freshAddress,
+            validator_src_address: transaction.sourceValidator,
+            validator_dst_address: validator.address,
+            amount: {
+              denom: account.currency.units[1].code,
+              amount: validator.amount.toString(),
+            },
+          },
+        };
+        aminoMsgs.push(aminoMsg);
+
+        // PROTO MESSAGE
+        protoMsgs.push({
+          typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+          value: MsgBeginRedelegate.encode({
+            delegatorAddress: account.freshAddress,
+            validatorSrcAddress: transaction.sourceValidator,
+            validatorDstAddress: validator.address,
+            amount: {
+              denom: account.currency.units[1].code,
+              amount: validator.amount.toString(),
+            },
+          }).finish(),
+        });
+      }
+      break;
+
+    case "undelegate":
+      if (transaction.validators && transaction.validators.length > 0) {
+        const validator = transaction.validators[0];
+        if (validator && validator.address /*&& transaction.amount.gt(0)*/) {
+          //todo verify what minimum is required by osmosis to undelegate
+          const aminoMsg: AminoMsgUndelegate = {
+            type: "cosmos-sdk/MsgUndelegate",
+            value: {
+              delegator_address: account.freshAddress,
+              validator_address: validator.address,
+              amount: {
+                denom: account.currency.units[1].code,
+                amount: validator.amount.toString(),
+              },
+            },
+          };
+          aminoMsgs.push(aminoMsg);
+
+          // PROTO MESSAGE
+          protoMsgs.push({
+            typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+            value: MsgUndelegate.encode({
+              delegatorAddress: account.freshAddress,
+              validatorAddress: validator.address,
+              amount: {
+                denom: account.currency.units[1].code,
+                amount: validator.amount.toString(),
+              },
+            }).finish(),
+          });
+        }
+      }
+      break;
+    case "claimReward":
+      if (
+        transaction.validators &&
+        transaction.validators.length > 0 &&
+        transaction.validators[0].address
+      ) {
+        const validator = transaction.validators[0];
+        const aminoMsg: AminoMsgWithdrawDelegatorReward = {
+          type: "cosmos-sdk/MsgWithdrawDelegationReward",
+          value: {
+            delegator_address: account.freshAddress,
+            validator_address: validator.address,
+          },
+        };
+        aminoMsgs.push(aminoMsg);
+
+        // PROTO MESSAGE
+        protoMsgs.push({
+          typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+          value: MsgWithdrawDelegatorReward.encode({
+            delegatorAddress: account.freshAddress,
+            validatorAddress: validator.address,
+          }).finish(),
+        });
+      }
+      break;
+    case "claimRewardCompound":
+      if (
+        transaction.validators &&
+        transaction.validators.length > 0 &&
+        transaction.validators[0].address &&
+        transaction.validators[0].amount.gt(0)
+      ) {
+        const validator = transaction.validators[0];
+        // AMINO MESSAGES
+        const aminoWithdrawRewardMsg: AminoMsgWithdrawDelegatorReward = {
+          type: "cosmos-sdk/MsgWithdrawDelegationReward",
+          value: {
+            delegator_address: account.freshAddress,
+            validator_address: validator.address,
+          },
+        };
+        const aminoDelegateMsg: AminoMsgDelegate = {
+          type: "cosmos-sdk/MsgDelegate",
+          value: {
+            delegator_address: account.freshAddress,
+            validator_address: validator.address,
+            amount: {
+              denom: account.currency.units[1].code,
+              amount: validator.amount.toString(),
+            },
+          },
+        };
+        aminoMsgs.push(aminoWithdrawRewardMsg, aminoDelegateMsg);
+
+        // PROTO MESSAGES
+        protoMsgs.push({
+          typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+          value: MsgWithdrawDelegatorReward.encode({
+            delegatorAddress: account.freshAddress,
+            validatorAddress: validator.address,
+          }).finish(),
+        });
+        protoMsgs.push({
+          typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+          value: MsgDelegate.encode({
+            delegatorAddress: account.freshAddress,
+            validatorAddress: validator.address,
+            amount: {
+              denom: account.currency.units[1].code,
+              amount: validator.amount.toString(),
+            },
+          }).finish(),
+        });
+      }
+      break;
+  }
+  return { aminoMsgs, protoMsgs };
+};
+
+export const postBuildTransaction = async (
+  signResponse: AminoSignResponse,
+  protoMsgs: Array<ProtoMsg>
+): Promise<Uint8Array> => {
+  const signed_tx_bytes = TxRaw.encode({
+    bodyBytes: TxBody.encode(
+      TxBody.fromPartial({
+        messages: protoMsgs,
+        memo: signResponse.signed.memo,
+        timeoutHeight: undefined,
+        extensionOptions: [],
+        nonCriticalExtensionOptions: [],
+      })
+    ).finish(),
+    authInfoBytes: AuthInfo.encode({
+      signerInfos: [
+        {
+          publicKey: {
+            typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+            value: PubKey.encode({
+              key: Buffer.from(signResponse.signature.pub_key.value, "base64"),
+            }).finish(),
+          },
+          modeInfo: {
+            single: {
+              mode: SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
+            },
+            multi: undefined,
+          },
+          sequence: Long.fromString(signResponse.signed.sequence),
+        },
+      ],
+      fee: Fee.fromPartial({
+        amount: signResponse.signed.fee.amount
+          ? (signResponse.signed.fee.amount as Coin[])
+          : undefined,
+        gasLimit: signResponse.signed.fee.gas,
+      }),
+    }).finish(),
+    signatures: [Buffer.from(signResponse.signature.signature, "base64")],
+  }).finish();
+
+  return signed_tx_bytes;
+};
+
+export default buildTransaction;

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

@@ -0,0 +1,26 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import { getMainAccount } from "../../account";
+import getEstimatedFees from "./js-getFeesForTransaction";
+import { CosmosOperationMode } from "../cosmos/types";
+
+/**
+ * Returns the maximum possible amount for transaction, considering fees
+ *
+ * @param {Object} param - account, parentAccount
+ */
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  mode,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  mode: CosmosOperationMode;
+}): Promise<BigNumber> => {
+  const a = getMainAccount(account, parentAccount);
+  const fees = await getEstimatedFees(mode);
+  return BigNumber.max(0, a.spendableBalance.minus(fees));
+};
+
+export default estimateMaxSpendable;