@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/internet_computer/bridge/account.ts

@@ -1,230 +1,19 @@
-import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import {
-  Account,
-  AccountBridge,
-  AccountLike,
-  BroadcastFnSignature,
-  SignOperationFnSignature,
-} from "@ledgerhq/types-live";
-import { InternetComputerOperation, Transaction, TransactionStatus } from "../types";
+import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { prepareTransaction } from "../prepareTransaction";
+import { Transaction, TransactionStatus } from "../types";
 import { getAccountShape } from "./bridgeHelpers/account";
-import BigNumber from "bignumber.js";
-import { getEstimatedFees } from "./bridgeHelpers/fee";
-import { getAddress, validateAddress, validateMemo } from "./bridgeHelpers/addresses";
-import {
-  AmountRequired,
-  InvalidAddress,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughBalance,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import { Observable } from "rxjs";
-import { withDevice } from "../../../hw/deviceAccess";
-import { encodeOperationId } from "../../../operation";
-import {
-  broadcastTxn,
-  getTxnExpirationDate,
-  getTxnMetadata,
-  getUnsignedTransaction,
-  signICPTransaction,
-} from "./bridgeHelpers/icpRosetta";
-import { getPath } from "../utils";
-import { InvalidMemoICP } from "../errors";
+import { createTransaction } from "../createTransaction";
+import { signOperation } from "../signOperation";
+import { broadcast } from "../broadcast";
 
 const sync = makeSync({ getAccountShape });
-
-const createTransaction = (): Transaction => {
-  // log("debug", "[createTransaction] creating base tx");
-  return {
-    family: "internet_computer",
-    amount: new BigNumber(0),
-    fees: getEstimatedFees(),
-    recipient: "",
-    useAllAmount: false,
-  };
-};
-
-const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
-  // log("debug", "[prepareTransaction] start fn");
-
-  const { address } = getAddress(a);
-  const { recipient } = t;
-
-  let amount: BigNumber = t.amount;
-  if (recipient && address) {
-    // log("debug", "[prepareTransaction] fetching estimated fees");
-
-    if ((await validateAddress(recipient)).isValid && (await validateAddress(address)).isValid) {
-      if (t.useAllAmount) {
-        amount = a.spendableBalance.minus(t.fees);
-        return { ...t, amount };
-      }
-    }
-  }
-
-  // log("debug", "[prepareTransaction] finish fn");
-  return t;
-};
-
-const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
-  const errors: TransactionStatus["errors"] = {};
-  const warnings: TransactionStatus["warnings"] = {};
-
-  const { balance } = a;
-  const { address } = getAddress(a);
-  const { recipient, useAllAmount } = t;
-  let { amount } = t;
-
-  if (!recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (!(await validateAddress(recipient)).isValid) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: a.currency.name,
-    });
-  } else if (recipient.toLowerCase() === address.toLowerCase()) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  }
-
-  if (!(await validateAddress(address)).isValid) {
-    errors.sender = new InvalidAddress("", {
-      currencyName: a.currency.name,
-    });
-  }
-
-  if (!validateMemo(t.memo).isValid) {
-    errors.transaction = new InvalidMemoICP();
-  }
-
-  // This is the worst case scenario (the tx won't cost more than this value)
-  const estimatedFees = t.fees;
-
-  let totalSpent: BigNumber;
-
-  if (useAllAmount) {
-    totalSpent = a.spendableBalance;
-    amount = totalSpent.minus(estimatedFees);
-    if (amount.lte(0) || totalSpent.gt(balance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-  } else {
-    totalSpent = amount.plus(estimatedFees);
-    if (amount.eq(0)) {
-      errors.amount = new AmountRequired();
-    } else if (totalSpent.gt(a.spendableBalance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-  }
-
-  // log("debug", "[getTransactionStatus] finish fn");
-
-  return {
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  };
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount?: Account | null | undefined;
-  transaction?: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const balance = account.balance;
-
-  let maxSpendable = balance.minus(transaction?.fees ?? getEstimatedFees());
-
-  if (maxSpendable.isLessThan(0)) {
-    maxSpendable = new BigNumber(0);
-  }
-
-  return maxSpendable;
-};
-
-const signOperation: SignOperationFnSignature<Transaction> = ({ account, deviceId, transaction }) =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        async function main() {
-          // log("debug", "[signOperation] start fn");
-
-          const { recipient, amount } = transaction;
-          const { id: accountId, xpub } = account;
-          const { address, derivationPath } = getAddress(account);
-          const fee = transaction.fees;
-
-          const { unsignedTxn, payloads } = await getUnsignedTransaction(transaction, account);
-
-          o.next({
-            type: "device-signature-requested",
-          });
-
-          const { signedTxn } = await signICPTransaction({
-            unsignedTxn,
-            transport,
-            path: getPath(derivationPath),
-            payloads,
-            pubkey: xpub ?? "",
-          });
-
-          const { hash } = await getTxnMetadata(signedTxn);
-
-          o.next({
-            type: "device-signature-granted",
-          });
-
-          const operation: InternetComputerOperation = {
-            id: encodeOperationId(accountId, hash, "OUT"),
-            hash,
-            type: "OUT",
-            senders: [address],
-            recipients: [recipient],
-            accountId,
-            value: amount.plus(fee),
-            fee,
-            blockHash: null,
-            blockHeight: null,
-            date: new Date(),
-            extra: {
-              memo: transaction.memo,
-            },
-          };
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature: signedTxn,
-              expirationDate: getTxnExpirationDate(unsignedTxn),
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
 const receive = makeAccountBridgeReceive();
 
-const broadcast: BroadcastFnSignature = async ({ signedOperation: { signature, operation } }) => {
-  // log("debug", "[broadcast] start fn");
-
-  await broadcastTxn(signature);
-
-  const result = { ...operation };
-
-  return result;
-};
-
-export const accountBridge: AccountBridge<Transaction> = {
+export const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   sync,
   updateTransaction: defaultUpdateTransaction,
   createTransaction,

package/src/families/internet_computer/bridge/bridgeHelpers/account.ts

@@ -12,6 +12,52 @@ import { InternetComputerOperation } from "../../types";
 import invariant from "invariant";
 import { deriveAddressFromPubkey } from "./icpRosetta";
 
+export const getAccountShape: GetAccountShape = async info => {
+  const { currency, derivationMode, rest = {}, initialAccount } = info;
+  const publicKey = reconciliatePublicKey(rest.publicKey, initialAccount);
+  invariant(publicKey, "publicKey is required");
+
+  // deriving address from public key
+  const address = await deriveAddressFromPubkey(publicKey);
+  invariant(address, "address is required");
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  // log("debug", `Generation account shape for ${address}`);
+
+  const blockHeight = await fetchBlockHeight();
+  const balanceResp = await fetchBalances(address);
+  const balance = balanceResp.balances[0];
+
+  const txns = await fetchTxns(address);
+  const result: Partial<Account> = {
+    id: accountId,
+    balance: BigNumber(balance.value),
+    spendableBalance: BigNumber(balance.value),
+    operations: flatMap(txns.transactions.reverse(), mapTxToOps(accountId, address)),
+    blockHeight: blockHeight.current_block_identifier.index,
+    operationsCount: txns.transactions.length,
+    xpub: publicKey,
+  };
+
+  return result;
+};
+
+function reconciliatePublicKey(publicKey?: string, initialAccount?: Account): string {
+  if (publicKey) return publicKey;
+  if (initialAccount) {
+    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
+    return xpubOrAddress;
+  }
+  throw new Error("publicKey wasn't properly restored");
+}
+
 const mapTxToOps = (accountId: string, address: string, fee = ICP_FEES) => {
   return (
     txInfo: ICPRosettaGetTxnsHistoryResponse["transactions"][0],
@@ -86,49 +132,3 @@ const mapTxToOps = (accountId: string, address: string, fee = ICP_FEES) => {
     return ops;
   };
 };
-
-export const getAccountShape: GetAccountShape = async info => {
-  const { currency, derivationMode, rest = {}, initialAccount } = info;
-  const publicKey = reconciliatePublicKey(rest.publicKey, initialAccount);
-  invariant(publicKey, "publicKey is required");
-
-  // deriving address from public key
-  const address = await deriveAddressFromPubkey(publicKey);
-  invariant(address, "address is required");
-
-  const accountId = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress: publicKey,
-    derivationMode,
-  });
-
-  // log("debug", `Generation account shape for ${address}`);
-
-  const blockHeight = await fetchBlockHeight();
-  const balanceResp = await fetchBalances(address);
-  const balance = balanceResp.balances[0];
-
-  const txns = await fetchTxns(address);
-  const result: Partial<Account> = {
-    id: accountId,
-    balance: BigNumber(balance.value),
-    spendableBalance: BigNumber(balance.value),
-    operations: flatMap(txns.transactions.reverse(), mapTxToOps(accountId, address)),
-    blockHeight: blockHeight.current_block_identifier.index,
-    operationsCount: txns.transactions.length,
-    xpub: publicKey,
-  };
-
-  return result;
-};
-
-function reconciliatePublicKey(publicKey?: string, initialAccount?: Account): string {
-  if (publicKey) return publicKey;
-  if (initialAccount) {
-    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
-    return xpubOrAddress;
-  }
-  throw new Error("publicKey wasn't properly restored");
-}

package/src/families/internet_computer/broadcast.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { broadcastTxn } from "./bridge/bridgeHelpers/icpRosetta";
+import { Transaction } from "./types";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  // log("debug", "[broadcast] start fn");
+
+  await broadcastTxn(signature);
+
+  const result = { ...operation };
+
+  return result;
+};

package/src/families/internet_computer/buildOptimisticOperation.ts

@@ -0,0 +1,32 @@
+import { OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "../../operation";
+import { InternetComputerOperation } from "./types";
+import { getAddress } from "./bridge/bridgeHelpers/addresses";
+
+export const buildOptimisticOperation = async (
+  account,
+  transaction,
+  hash,
+  operationType: OperationType = "OUT",
+): Promise<InternetComputerOperation> => {
+  const { id: accountId } = account;
+  const { recipient, amount } = transaction;
+  const { address } = getAddress(account);
+
+  return {
+    id: encodeOperationId(accountId, hash, operationType),
+    hash,
+    type: "OUT",
+    senders: [address],
+    recipients: [recipient],
+    accountId,
+    value: amount.plus(transaction.fees),
+    fee: transaction.fees,
+    blockHash: null,
+    blockHeight: null,
+    date: new Date(),
+    extra: {
+      memo: transaction.memo,
+    },
+  };
+};

package/src/families/internet_computer/createTransaction.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+import { getEstimatedFees } from "./bridge/bridgeHelpers/fee";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  // log("debug", "[createTransaction] creating base tx");
+  return {
+    family: "internet_computer",
+    amount: new BigNumber(0),
+    fees: getEstimatedFees(),
+    recipient: "",
+    useAllAmount: false,
+  };
+};

package/src/families/internet_computer/estimateMaxSpendable.ts

@@ -0,0 +1,19 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getEstimatedFees } from "./bridge/bridgeHelpers/fee";
+import { Transaction } from "./types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  transaction,
+}) => {
+  const balance = account.balance;
+
+  let maxSpendable = balance.minus(transaction?.fees ?? getEstimatedFees());
+
+  if (maxSpendable.isLessThan(0)) {
+    maxSpendable = new BigNumber(0);
+  }
+
+  return maxSpendable;
+};

package/src/families/internet_computer/getTransactionStatus.ts

@@ -0,0 +1,75 @@
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getAddress, validateAddress, validateMemo } from "./bridge/bridgeHelpers/addresses";
+import { Transaction, TransactionStatus } from "./types";
+import { InvalidMemoICP } from "./errors";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const { recipient, useAllAmount } = transaction;
+  let { amount } = transaction;
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!(await validateAddress(recipient)).isValid) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  } else if (recipient.toLowerCase() === address.toLowerCase()) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!(await validateAddress(address)).isValid) {
+    errors.sender = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!validateMemo(transaction.memo).isValid) {
+    errors.transaction = new InvalidMemoICP();
+  }
+
+  // This is the worst case scenario (the tx won't cost more than this value)
+  const estimatedFees = transaction.fees;
+
+  let totalSpent: BigNumber;
+
+  if (useAllAmount) {
+    totalSpent = account.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    } else if (totalSpent.gt(account.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/families/internet_computer/prepareTransaction.ts

@@ -0,0 +1,28 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import { getAddress, validateAddress } from "./bridge/bridgeHelpers/addresses";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  // log("debug", "[prepareTransaction] start fn");
+
+  const { address } = getAddress(account);
+  const { recipient } = transaction;
+
+  let amount = transaction.amount;
+  if (recipient && address) {
+    // log("debug", "[prepareTransaction] fetching estimated fees");
+
+    if ((await validateAddress(recipient)).isValid && (await validateAddress(address)).isValid) {
+      if (transaction.useAllAmount) {
+        amount = account.spendableBalance.minus(transaction.fees);
+        return { ...transaction, amount };
+      }
+    }
+  }
+
+  // log("debug", "[prepareTransaction] finish fn");
+  return transaction;
+};

package/src/families/internet_computer/signOperation.ts

@@ -0,0 +1,64 @@
+import { Observable } from "rxjs";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getAddress } from "./bridge/bridgeHelpers/addresses";
+import {
+  getTxnExpirationDate,
+  getTxnMetadata,
+  getUnsignedTransaction,
+  signICPTransaction,
+} from "./bridge/bridgeHelpers/icpRosetta";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { withDevice } from "../../hw/deviceAccess";
+import { Transaction } from "./types";
+import { getPath } from "./utils";
+
+export const signOperation: AccountBridge<Transaction>["signOperation"] = ({
+  account,
+  deviceId,
+  transaction,
+}) =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          // log("debug", "[signOperation] start fn");
+
+          const { xpub } = account;
+          const { derivationPath } = getAddress(account);
+          const { unsignedTxn, payloads } = await getUnsignedTransaction(transaction, account);
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const { signedTxn } = await signICPTransaction({
+            unsignedTxn,
+            transport,
+            path: getPath(derivationPath),
+            payloads,
+            pubkey: xpub ?? "",
+          });
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          const { hash } = await getTxnMetadata(signedTxn);
+          const operation = await buildOptimisticOperation(account, transaction, hash);
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: signedTxn,
+              expirationDate: getTxnExpirationDate(unsignedTxn),
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );