@ledgerhq/live-common 21.28.0 → 21.31.0

package/src/families/celo/specs.ts

@@ -0,0 +1,53 @@
+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";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+const maxAccount = 3;
+
+const celo: AppSpec<Transaction> = {
+  name: "Celo",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Celo",
+  },
+  testTimeout: 2 * 60 * 1000,
+  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 }],
+        };
+      },
+    },
+    {
+      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 }],
+        };
+      },
+    },
+  ],
+};
+
+export default {
+  celo,
+};

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

@@ -0,0 +1,51 @@
+import type { DeviceAction } from "../../bot/types";
+import type { Transaction } from "./types";
+import { deviceActionFlow } from "../../bot/specs";
+import { formatCurrencyUnit } from "../../currencies";
+const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: "Rr",
+    },
+    {
+      title: "Amount",
+      button: "Rr",
+      expectedValue: ({ account, status }) => {
+        const formattedValue =
+          "CELO " +
+          formatCurrencyUnit(account.unit, status.amount, {
+            disableRounding: true,
+          });
+
+        if (!formattedValue.includes(".")) {
+          // if the value is pure integer, in the app it will automatically add an .0
+          return formattedValue + ".0";
+        }
+
+        return formattedValue;
+      },
+    },
+    {
+      title: "Address",
+      button: "Rr",
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Max Fees",
+      button: "Rr",
+      expectedValue: () => "CELO",
+    },
+    {
+      title: "No Gateway Fee",
+      button: "Rr",
+    },
+    {
+      title: "Accept",
+      button: "LRlr",
+    },
+  ],
+});
+export default {
+  acceptTransaction,
+};

package/src/families/celo/transaction.ts

@@ -0,0 +1,39 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  fromTransactionCommonRaw,
+  toTransactionCommonRaw,
+} from "../../transaction/common";
+import type { Account } from "../../types";
+import { getAccountUnit } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+export const formatTransaction = (t: Transaction, account: Account): string => `
+SEND ${formatCurrencyUnit(getAccountUnit(account), t.amount, {
+  showCode: true,
+  disableRounding: true,
+})}
+TO ${t.recipient}`;
+
+const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    fees: tr.fees ? new BigNumber(tr.fees) : null,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    fees: t.fees?.toString() || null,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+};

package/src/families/celo/types.ts

@@ -0,0 +1,20 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  TransactionCommon,
+  TransactionCommonRaw,
+} from "../../types/transaction";
+
+export type Transaction = TransactionCommon & {
+  family: "celo";
+  fees: BigNumber | null | undefined;
+};
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "celo";
+  fees: string | null | undefined;
+};
+
+export type CoreStatics = Record<string, never>;
+export type CoreAccountSpecifics = Record<string, never>;
+export type CoreOperationSpecifics = Record<string, never>;
+export type CoreCurrencySpecifics = Record<string, never>;
+export const reflect = (_declare: any) => {};

package/src/families/ethereum/datasets/ethereum.scanAccounts.1.ts

@@ -1,5 +1,6 @@
 export default {
   name: "ethereum seed 1",
+  unstableAccounts: true, // FIXME LL-9155
   apdus: `
     => e00200000d038000002c8000003c80000000
     <= 410469877df9567b58e6ef8f6cf1fb8a8e1bf28a327dee31b183a6b9cd1f3da063af0924506a9912793ef31e41df19f8653fa31bb1fecc32d2e41abdddb22ccb621028373561453661383832363036353137343345356546433033373937313136413335363539663638359000

package/src/families/ethereum/modules/erc1155.ts

@@ -14,6 +14,9 @@ import { prepareTransaction } from "./erc721";
 const notOwnedNft = createCustomErrorClass("NotOwnedNft");
 const notEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
 const notTokenIdsProvided = createCustomErrorClass("NotTokenIdsProvided");
+const quantityNeedsToBePositive = createCustomErrorClass(
+  "QuantityNeedsToBePositive"
+);
 
 export type Modes = "erc1155.transfer";
 
@@ -43,6 +46,12 @@ const erc1155Transfer: ModeModule = {
         result.errors.amount = new NotEnoughBalanceInParentAccount();
       }
 
+      t.quantities?.forEach((quantity) => {
+        if (quantity.isLessThan(1)) {
+          result.errors.amount = new quantityNeedsToBePositive();
+        }
+      });
+
       const enoughTokensOwned: true | Error =
         t.tokenIds?.reduce((acc, tokenId, index) => {
           if (acc instanceof Error) {

package/src/families/polkadot/cache.ts

@@ -87,7 +87,7 @@ export const getTransactionParams: CacheRes<
 );
 
 /**
- * Cache the payment info (fee estimate), with a hash deending on fees-changing transaction params and tx size.
+ * Cache the payment info (fee estimate), with a hash depending on fees-changing transaction params and tx size.
  *
  * @param {Account} arg1.a
  * @param {Transaction} arg1.t

package/src/families/solana/api/chain/index.ts

@@ -4,17 +4,16 @@ import {
   TOKEN_PROGRAM_ID,
 } from "@solana/spl-token";
 import {
-  Cluster,
-  clusterApiUrl,
   Connection,
   FeeCalculator,
   PublicKey,
+  sendAndConfirmRawTransaction,
   SignaturesForAddressOptions,
 } from "@solana/web3.js";
 import { Awaited } from "../../logic";
 
 export type Config = {
-  readonly cluster: Cluster;
+  readonly endpoint: string;
 };
 
 export type ChainAPI = Readonly<{
@@ -59,8 +58,7 @@ export type ChainAPI = Readonly<{
 }>;
 
 export function getChainAPI(config: Config): ChainAPI {
-  const connection = () =>
-    new Connection(clusterApiUrl(config.cluster), "finalized");
+  const connection = () => new Connection(config.endpoint, "finalized");
 
   return {
     getBalance: (address: string) =>
@@ -96,8 +94,11 @@ export function getChainAPI(config: Config): ChainAPI {
         .getParsedAccountInfo(new PublicKey(address))
         .then((r) => r.value),
 
-    sendRawTransaction: (buffer: Buffer) =>
-      connection().sendRawTransaction(buffer),
+    sendRawTransaction: (buffer: Buffer) => {
+      return sendAndConfirmRawTransaction(connection(), buffer, {
+        commitment: "confirmed",
+      });
+    },
 
     findAssocTokenAccAddress: (owner: string, mint: string) =>
       Token.getAssociatedTokenAddress(

package/src/families/solana/bridge/bridge.ts

@@ -22,7 +22,7 @@ import { broadcastWithAPI } from "../js-broadcast";
 import { prepareTransaction as prepareTransactionWithAPI } from "../js-prepareTransaction";
 import { ChainAPI, Config } from "../api";
 import { makeLRUCache } from "../../../cache";
-import { clusterByCurrencyId } from "../utils";
+import { endpointByCurrencyId } from "../utils";
 import { minutes, seconds } from "../api/cached";
 import hash from "object-hash";
 import BigNumber from "bignumber.js";
@@ -32,8 +32,8 @@ function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
     mainAccount: Account,
     transaction: Transaction
   ) {
-    const config = {
-      cluster: clusterByCurrencyId(mainAccount.currency.id),
+    const config: Config = {
+      endpoint: endpointByCurrencyId(mainAccount.currency.id),
     };
 
     const chainAPI = await getChainAPI(config);
@@ -61,8 +61,8 @@ function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
 
 function makeSyncAndScan(getChainAPI: (config: Config) => Promise<ChainAPI>) {
   const getAccountShape: GetAccountShape = async (info) => {
-    const config = {
-      cluster: clusterByCurrencyId(info.currency.id),
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.currency.id),
     };
 
     const chainAPI = await getChainAPI(config);
@@ -91,8 +91,8 @@ function makeEstimateMaxSpendable(
       throw new Error("currency not found");
     }
 
-    const config = {
-      cluster: clusterByCurrencyId(currencyId),
+    const config: Config = {
+      endpoint: endpointByCurrencyId(currencyId),
     };
 
     const api = await getChainAPI(config);
@@ -110,8 +110,8 @@ function makeBroadcast(
   getChainAPI: (config: Config) => Promise<ChainAPI>
 ): BroadcastFnSignature {
   return async (info) => {
-    const config = {
-      cluster: clusterByCurrencyId(info.account.currency.id),
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.account.currency.id),
     };
     const api = await getChainAPI(config);
     return broadcastWithAPI(info, api);
@@ -122,8 +122,8 @@ function makeSign(
   getChainAPI: (config: Config) => Promise<ChainAPI>
 ): SignOperationFnSignature<Transaction> {
   return (info) => {
-    const config = {
-      cluster: clusterByCurrencyId(info.account.currency.id),
+    const config: Config = {
+      endpoint: endpointByCurrencyId(info.account.currency.id),
     };
     const api = () => getChainAPI(config);
     return signOperationWithAPI(info, api);

package/src/families/solana/bridge/js.ts

@@ -5,19 +5,19 @@ import { minutes } from "../api/cached";
 
 const getAPI = makeLRUCache(
   (config: Config) => Promise.resolve(getChainAPI(config)),
-  (config) => config.cluster,
+  (config) => config.endpoint,
   minutes(1000)
 );
 
 const getQueuedAPI = makeLRUCache(
   (config: Config) => getAPI(config).then((api) => queued(api, 100)),
-  (config) => config.cluster,
+  (config) => config.endpoint,
   minutes(1000)
 );
 
 const getQueuedAndCachedAPI = makeLRUCache(
   (config: Config) => getQueuedAPI(config).then(cached),
-  (config) => config.cluster,
+  (config) => config.endpoint,
   minutes(1000)
 );
 

package/src/families/solana/bridge/mock.ts

@@ -57,7 +57,7 @@ function createMockDataForAPI() {
       Promise.resolve(
         cached(queued(logged(getChainAPI(config), "/tmp/log"), 100))
       ),
-    (config) => config.cluster,
+    (config) => config.endpoint,
     minutes(1000)
   );
   return {