@ledgerhq/live-common 34.2.0 → 34.3.0-next.0

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

@@ -1,176 +0,0 @@
-import { RETURN_CODES, Transaction } from "./types";
-import { Observable } from "rxjs";
-import BigNumber from "bignumber.js";
-import { Secp256k1Signature } from "@cosmjs/crypto";
-import { CosmosApp } from "@zondax/ledger-cosmos-js";
-import { serializeSignDoc, makeSignDoc } from "@cosmjs/amino";
-import { UserRefusedOnDevice, ExpertModeRequired } from "@ledgerhq/errors";
-import { Coin } from "@keplr-wallet/proto-types/cosmos/base/v1beta1/coin";
-import type { Operation, OperationType, SignOperationFnSignature } from "@ledgerhq/types-live";
-import { withDevice } from "../../hw/deviceAccess";
-import { encodeOperationId } from "../../operation";
-import { txToMessages, buildTransaction } from "./js-buildTransaction";
-import { CosmosAPI } from "./api/Cosmos";
-import cryptoFactory from "./chain/chain";
-
-const signOperation: SignOperationFnSignature<Transaction> = ({ account, deviceId, transaction }) =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        let cancelled;
-
-        async function main() {
-          const cosmosAPI = new CosmosAPI(account.currency.id);
-          const chainInstance = cryptoFactory(account.currency.id);
-
-          const { accountNumber, sequence, pubKeyType } = await cosmosAPI.getAccount(
-            account.freshAddress,
-          );
-          o.next({ type: "device-signature-requested" });
-          const { aminoMsgs, protoMsgs } = txToMessages(account, transaction);
-          if (transaction.fees == null || transaction.gas == null) {
-            throw new Error("Transaction misses gas information");
-          }
-          const feeToEncode = {
-            amount: [
-              {
-                denom: account.currency.units[1].code,
-                amount: transaction.fees.toFixed(),
-              },
-            ],
-            gas: transaction.gas.toFixed(),
-          };
-          // Note:
-          // Cosmos Nano App sign data in Amino way only, not Protobuf.
-          // This is a legacy outdated standard and a long-term blocking point.
-          const chainId = await cosmosAPI.getChainId();
-          const signDoc = makeSignDoc(
-            aminoMsgs,
-            feeToEncode,
-            chainId,
-            transaction.memo || "",
-            accountNumber.toString(),
-            sequence.toString(),
-          );
-          const tx = Buffer.from(serializeSignDoc(signDoc));
-          const app = new CosmosApp(transport);
-          const path = account.freshAddressPath.split("/").map(p => parseInt(p.replace("'", "")));
-
-          const { compressed_pk } = await app.getAddressAndPubKey(path, chainInstance.prefix);
-          const pubKey = Buffer.from(compressed_pk).toString("base64");
-
-          // HRP is only needed when signing for ethermint chains
-          const signResponseApp =
-            path[1] === 60
-              ? await app.sign(path, tx, chainInstance.prefix)
-              : await app.sign(path, tx);
-
-          switch (signResponseApp.return_code) {
-            case RETURN_CODES.EXPERT_MODE_REQUIRED:
-              throw new ExpertModeRequired();
-            case RETURN_CODES.REFUSED_OPERATION:
-              throw new UserRefusedOnDevice();
-          }
-
-          const signature = Buffer.from(
-            Secp256k1Signature.fromDer(signResponseApp.signature).toFixedLength(),
-          );
-
-          const txBytes = buildTransaction({
-            protoMsgs,
-            memo: transaction.memo || "",
-            pubKeyType,
-            pubKey,
-            feeAmount: signDoc.fee.amount as Coin[],
-            gasLimit: signDoc.fee.gas,
-            sequence: signDoc.sequence,
-            signature,
-          });
-
-          const signed = Buffer.from(txBytes).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(0);
-          const extra = {};
-
-          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:
-              type === "REWARD"
-                ? new BigNumber(0)
-                : transaction.useAllAmount
-                ? account.spendableBalance
-                : transaction.amount.plus(fee),
-            fee,
-            extra,
-            blockHash: null,
-            blockHeight: null,
-            senders,
-            recipients,
-            accountId,
-            date: new Date(),
-            transactionSequenceNumber: sequence,
-          };
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature: signed,
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-
-        return () => {
-          cancelled = true;
-        };
-      }),
-  );
-
-export default signOperation;

package/src/families/cosmos/js-synchronisation.ts

@@ -1,259 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import {
-  makeSync,
-  makeScanAccounts,
-  GetAccountShape,
-  mergeOps,
-  AccountShapeInfo,
-} from "../../bridge/jsHelpers";
-import { encodeAccountId } from "../../account";
-import { CosmosAPI } from "./api/Cosmos";
-import { encodeOperationId } from "../../operation";
-import { CosmosOperation, CosmosMessage, CosmosTx } from "./types";
-import type { OperationType } from "@ledgerhq/types-live";
-import { getMainMessage } from "./helpers";
-import { parseAmountStringToNumber } from "./logic";
-
-const getBlankOperation = (tx: CosmosTx, fees: BigNumber, accountId: string): CosmosOperation => {
-  return {
-    id: "",
-    hash: tx.txhash,
-    type: "" as OperationType,
-    value: new BigNumber(0),
-    fee: fees,
-    blockHash: null,
-    blockHeight: parseInt(tx.height),
-    senders: [] as string[],
-    recipients: [] as string[],
-    accountId,
-    date: new Date(tx.timestamp),
-    extra: {},
-    transactionSequenceNumber: parseInt(tx?.tx?.auth_info?.signer_infos[0]?.sequence || "0"),
-  };
-};
-
-const txToOps = (info: AccountShapeInfo, accountId: string, txs: CosmosTx[]): CosmosOperation[] => {
-  const { address, currency } = info;
-  const unitCode = currency.units[1].code;
-  const ops: CosmosOperation[] = [];
-  for (const tx of txs) {
-    const amounts = tx?.tx?.auth_info?.fee?.amount;
-
-    const fees = !amounts
-      ? new BigNumber(0)
-      : amounts.reduce((acc: BigNumber, curr: { denom: string; amount: string }) => {
-          if (curr.denom === unitCode) {
-            return acc.plus(curr.amount);
-          }
-          return acc;
-        }, new BigNumber(0));
-
-    const op: CosmosOperation = getBlankOperation(tx, fees, accountId);
-
-    op.hasFailed = tx.code !== 0;
-
-    const messages: CosmosMessage[] = op.hasFailed
-      ? tx.events
-      : tx.logs.map(log => log.events).flat(1);
-
-    const mainMessage = getMainMessage(messages);
-
-    if (mainMessage === undefined) {
-      // happens when we don't know this message type in our implementation, example : proposal_vote
-      continue;
-    }
-
-    const correspondingMessages = messages.filter(m => m.type === mainMessage.type);
-
-    switch (mainMessage.type) {
-      case "transfer":
-        // TODO: handle IBC transfers here
-        for (const message of correspondingMessages) {
-          const amount = message.attributes.find(attr => attr.key === "amount")?.value;
-          const sender = message.attributes.find(attr => attr.key === "sender")?.value;
-          const recipient = message.attributes.find(attr => attr.key === "recipient")?.value;
-          if (amount && sender && recipient && amount.endsWith(unitCode)) {
-            if (op.senders.indexOf(sender) === -1) op.senders.push(sender);
-            if (op.recipients.indexOf(recipient) === -1) op.recipients.push(recipient);
-            op.value = op.value.plus(parseAmountStringToNumber(amount, unitCode));
-            if (sender === address) {
-              op.type = "OUT";
-            } else if (recipient === address) {
-              op.type = "IN";
-            }
-          }
-        }
-        if (op.type === "OUT") {
-          op.value = op.value.plus(fees);
-        }
-        break;
-
-      case "withdraw_rewards": {
-        op.type = "REWARD";
-        const rewardShards: { amount: BigNumber; address: string }[] = [];
-        let txRewardValue = new BigNumber(0);
-        for (const message of correspondingMessages) {
-          const validator = message.attributes.find(attr => attr.key === "validator")?.value;
-          const amount = message.attributes.find(attr => attr.key === "amount")?.value;
-          if (validator && amount && amount.endsWith(unitCode)) {
-            const amountString = parseAmountStringToNumber(amount, unitCode);
-            rewardShards.push({
-              amount: new BigNumber(amountString),
-              address: validator,
-            });
-            txRewardValue = txRewardValue.plus(amountString);
-          }
-        }
-        op.value = txRewardValue;
-        op.extra.validators = rewardShards;
-        break;
-      }
-      case "delegate": {
-        op.type = "DELEGATE";
-        op.value = new BigNumber(fees);
-        const delegateShards: { amount: BigNumber; address: string }[] = [];
-        for (const message of correspondingMessages) {
-          const amount = message.attributes.find(attr => attr.key === "amount")?.value;
-          const validator = message.attributes.find(attr => attr.key === "validator")?.value;
-          if (amount && validator && amount.endsWith(unitCode)) {
-            delegateShards.push({
-              amount: new BigNumber(parseAmountStringToNumber(amount, unitCode)),
-              address: validator,
-            });
-          }
-        }
-        op.extra.validators = delegateShards;
-        break;
-      }
-      case "redelegate": {
-        op.type = "REDELEGATE";
-        op.value = new BigNumber(fees);
-        const redelegateShards: { amount: BigNumber; address: string }[] = [];
-        for (const message of correspondingMessages) {
-          const amount = message.attributes.find(attr => attr.key === "amount")?.value;
-          const validatorDst = message.attributes.find(attr => attr.key === "destination_validator")
-            ?.value;
-          const validatorSrc = message.attributes.find(attr => attr.key === "source_validator")
-            ?.value;
-          if (amount && validatorDst && validatorSrc && amount.endsWith(unitCode)) {
-            op.extra.sourceValidator = validatorSrc;
-            redelegateShards.push({
-              amount: new BigNumber(parseAmountStringToNumber(amount, unitCode)),
-              address: validatorDst,
-            });
-          }
-        }
-        op.extra.validators = redelegateShards;
-        break;
-      }
-      case "unbond": {
-        op.type = "UNDELEGATE";
-        op.value = new BigNumber(fees);
-        const unbondShards: { amount: BigNumber; address: string }[] = [];
-        for (const message of correspondingMessages) {
-          const amount = message.attributes.find(attr => attr.key === "amount")?.value;
-          const validator = message.attributes.find(attr => attr.key === "validator")?.value;
-          if (amount && validator && amount.endsWith(unitCode)) {
-            unbondShards.push({
-              amount: new BigNumber(parseAmountStringToNumber(amount, unitCode)),
-              address: validator,
-            });
-          }
-        }
-        op.extra.validators = unbondShards;
-        break;
-      }
-    }
-
-    if (op.hasFailed) {
-      op.value = fees;
-    }
-
-    if (tx.tx.body.memo != null) {
-      op.extra.memo = tx.tx.body.memo;
-    }
-    op.id = encodeOperationId(accountId, tx.txhash, op.type);
-
-    if (op.type) {
-      ops.push(op);
-    }
-  }
-
-  return ops;
-};
-
-export const getAccountShape: GetAccountShape = async info => {
-  const { address, currency, derivationMode, initialAccount } = info;
-  const accountId = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress: address,
-    derivationMode,
-  });
-
-  const {
-    accountInfo,
-    balances,
-    blockHeight,
-    txs,
-    delegations,
-    redelegations,
-    unbondings,
-    withdrawAddress,
-  } = await new CosmosAPI(currency.id).getAccountInfo(address, currency);
-
-  const oldOperations = initialAccount?.operations || [];
-  const newOperations = txToOps(info, accountId, txs);
-  const operations = mergeOps(oldOperations, 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: address,
-    balance: balance,
-    spendableBalance,
-    operationsCount: operations.length,
-    blockHeight,
-    cosmosResources: {
-      delegations,
-      redelegations,
-      unbondings,
-      delegatedBalance,
-      pendingRewardsBalance,
-      unbondingBalance,
-      withdrawAddress,
-      sequence: accountInfo.sequence,
-    },
-  };
-
-  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 });