@ledgerhq/coin-tester-evm 1.8.0 → 1.8.1-nightly.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-tester-evm",
-  "version": "1.8.0",
+  "version": "1.8.1-nightly.1",
   "description": "Ledger EVM Coin Tester",
   "main": "src/scenarii.test.ts",
   "keywords": [
@@ -51,15 +51,15 @@
     "dotenv": "^16.4.5",
     "ethers": "6.15.0",
     "msw": "^2.2.1",
-    "@ledgerhq/coin-evm": "^2.31.0",
-    "@ledgerhq/coin-framework": "^6.5.0",
+    "@ledgerhq/coin-evm": "^2.32.0-nightly.0",
+    "@ledgerhq/coin-framework": "^6.6.0-nightly.0",
     "@ledgerhq/coin-tester": "^0.10.0",
-    "@ledgerhq/cryptoassets": "^13.29.0",
-    "@ledgerhq/live-common": "^34.49.0",
+    "@ledgerhq/cryptoassets": "^13.30.0-nightly.0",
+    "@ledgerhq/live-common": "^34.50.0-nightly.1",
     "@ledgerhq/live-config": "^3.2.0",
-    "@ledgerhq/live-signer-evm": "^0.8.0",
-    "@ledgerhq/types-cryptoassets": "^7.27.0",
-    "@ledgerhq/types-live": "^6.85.0"
+    "@ledgerhq/live-signer-evm": "^0.8.1-nightly.0",
+    "@ledgerhq/types-cryptoassets": "^7.28.0-nightly.0",
+    "@ledgerhq/types-live": "^6.86.0-nightly.0"
   },
   "devDependencies": {
     "@swc/core": "1.4.11",

package/src/helpers.ts

@@ -17,6 +17,7 @@ import { getAlpacaCurrencyBridge } from "@ledgerhq/live-common/bridge/generic-al
 import { getAlpacaAccountBridge } from "@ledgerhq/live-common/bridge/generic-alpaca/accountBridge";
 
 export const ethereum = getCryptoCurrencyById("ethereum");
+export const core = getCryptoCurrencyById("core");
 export const sonic = getCryptoCurrencyById("sonic");
 export const polygon = getCryptoCurrencyById("polygon");
 export const scroll = getCryptoCurrencyById("scroll");

package/src/scenarii/core.ts

@@ -0,0 +1,170 @@
+import { makeAccount } from "@ledgerhq/coin-evm/__tests__/fixtures/common.fixtures";
+import { buildAccountBridge, buildCurrencyBridge } from "@ledgerhq/coin-evm/bridge/js";
+import { getCoinConfig, setCoinConfig } from "@ledgerhq/coin-evm/config";
+import resolver from "@ledgerhq/coin-evm/hw-getAddress";
+import { EvmSigner } from "@ledgerhq/coin-evm/types/signer";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/transaction";
+import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Scenario, ScenarioTransaction } from "@ledgerhq/coin-tester/main";
+import { killSpeculos, spawnSpeculos } from "@ledgerhq/coin-tester/signers/speculos";
+import { getTokenById } from "@ledgerhq/cryptoassets/tokens";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
+import { LegacySignerEth } from "@ledgerhq/live-signer-evm";
+import { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { ethers } from "ethers";
+import { killAnvil, spawnAnvil } from "../anvil";
+import { VITALIK, core } from "../helpers";
+import { indexBlocks, initMswHandlers, resetIndexer, setBlock } from "../indexer";
+import { defaultNanoApp } from "../scenarii.test";
+
+type CoreScenarioTransaction = ScenarioTransaction<EvmTransaction, Account>;
+
+const STCORE_ON_CORE = getTokenById(
+  "core/erc20/liquid_staked_core_0xb3a8f0f0da9ffc65318aa39e55079796093029ad",
+);
+
+const makeScenarioTransactions = ({ address }: { address: string }): CoreScenarioTransaction[] => {
+  const scenarioSendSTransaction: CoreScenarioTransaction = {
+    name: "Send 1 CORE",
+    amount: new BigNumber(1e18),
+    recipient: VITALIK,
+    expect: (previousAccount, currentAccount) => {
+      const [latestOperation] = currentAccount.operations;
+      expect(currentAccount.operations.length - previousAccount.operations.length).toBe(1);
+      expect(latestOperation.type).toBe("OUT");
+      expect(latestOperation.value.toFixed()).toBe(latestOperation.fee.plus(1e18).toFixed());
+      expect(currentAccount.balance.toFixed()).toBe(
+        previousAccount.balance.minus(latestOperation.value).toFixed(),
+      );
+    },
+  };
+
+  // TODO: export when explorer is ready because last token operations come from explorer
+  const _scenarioSendSTCORETransaction: CoreScenarioTransaction = {
+    name: "Send STCORE",
+    amount: new BigNumber(ethers.parseUnits("80", STCORE_ON_CORE.units[0].magnitude).toString()),
+    recipient: VITALIK,
+    subAccountId: encodeTokenAccountId(`js:2:core:${address}:`, STCORE_ON_CORE),
+    expect: (previousAccount, currentAccount) => {
+      const [latestOperation] = currentAccount.operations;
+      expect(currentAccount.operations.length - previousAccount.operations.length).toBe(1);
+      expect(latestOperation.type).toBe("FEES");
+      expect(latestOperation.value.toFixed()).toBe(latestOperation.fee.toFixed());
+      expect(latestOperation.subOperations?.[0].type).toBe("OUT");
+      expect(latestOperation.subOperations?.[0].value.toFixed()).toBe(
+        ethers.parseUnits("80", STCORE_ON_CORE.units[0].magnitude).toString(),
+      );
+      expect(currentAccount.subAccounts?.[0].balance.toFixed()).toBe(
+        ethers.parseUnits("20", STCORE_ON_CORE.units[0].magnitude).toString(),
+      );
+    },
+  };
+
+  return [scenarioSendSTransaction];
+};
+
+export const scenarioCore: Scenario<EvmTransaction, Account> = {
+  name: "Ledger Live Basic CORE Transactions",
+  setup: async () => {
+    const [{ transport, getOnSpeculosConfirmation }] = await Promise.all([
+      spawnSpeculos(`/${defaultNanoApp.firmware}/Ethereum/app_${defaultNanoApp.version}.elf`),
+      spawnAnvil("https://rpc.ankr.com/core"),
+    ]);
+    const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
+    const signerContext: SignerContext<EvmSigner> = (_, fn) => fn(new LegacySignerEth(transport));
+
+    setCoinConfig(() => ({
+      info: {
+        status: {
+          type: "active",
+        },
+        node: {
+          type: "external",
+          uri: "http://127.0.0.1:8545",
+        },
+        explorer: {
+          type: "none",
+        },
+        showNfts: true,
+      },
+    }));
+    LiveConfig.setConfig({
+      config_currency_core: {
+        type: "object",
+        default: {
+          status: {
+            type: "active",
+          },
+          node: {
+            type: "external",
+            uri: "http://127.0.0.1:8545",
+          },
+          explorer: {
+            type: "none",
+          },
+          showNfts: false,
+        },
+      },
+    });
+
+    initMswHandlers(getCoinConfig(core).info);
+
+    const onSignerConfirmation = getOnSpeculosConfirmation();
+    const currencyBridge = buildCurrencyBridge(signerContext);
+    await currencyBridge.preload(core);
+    const accountBridge = buildAccountBridge(signerContext);
+    const getAddress = resolver(signerContext);
+    const { address } = await getAddress("", {
+      path: "44'/60'/0'/0/0",
+      currency: core,
+      derivationMode: "",
+    });
+
+    const scenarioAccount = makeAccount(address, core);
+
+    const lastBlockNumber = await provider.getBlockNumber();
+    // start indexing at next block
+    setBlock(lastBlockNumber + 1);
+
+    // Get STCORE
+    // TODO: uncomment when explorer is ready
+    // await callMyDealer({
+    //   provider,
+    //   drug: STCORE_ON_CORE,
+    //   junkie: address,
+    //   dose: ethers.parseUnits("100", STCORE_ON_CORE.units[0].magnitude),
+    // });
+
+    return {
+      currencyBridge,
+      accountBridge,
+      account: scenarioAccount,
+      onSignerConfirmation,
+    };
+  },
+  beforeAll: account => {
+    expect(account.balance.toFixed()).toBe(ethers.parseEther("10000").toString());
+    // TODO: uncomment when explorer is ready
+    // expect(account.subAccounts?.[0]?.type).toBe("TokenAccount");
+    // expect(account.subAccounts?.[0]?.balance?.toFixed()).toBe(
+    //   ethers.parseUnits("100", STCORE_ON_CORE.units[0].magnitude).toString(),
+    // );
+  },
+  getTransactions: address => makeScenarioTransactions({ address }),
+  beforeSync: async () => {
+    await indexBlocks();
+  },
+  afterAll: _account => {
+    // TODO: uncomment when explorer is ready
+    // expect(account.subAccounts?.length).toBe(1);
+    // expect(account.subAccounts?.[0].balance.toFixed()).toBe(
+    //   ethers.parseUnits("20", STCORE_ON_CORE.units[0].magnitude).toString(),
+    // );
+  },
+  teardown: async () => {
+    resetIndexer();
+    await Promise.all([killSpeculos(), killAnvil()]);
+  },
+};

package/src/scenarii.test.ts

@@ -6,6 +6,7 @@ import { scenarioPolygon } from "./scenarii/polygon";
 import { scenarioScroll } from "./scenarii/scroll";
 import { scenarioBlast } from "./scenarii/blast";
 import { scenarioSonic } from "./scenarii/sonic";
+import { scenarioCore } from "./scenarii/core";
 import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
@@ -63,6 +64,17 @@ describe.each([["legacy"], ["generic-adapter"]] as const)(
       }
     });
 
+    it("scenario Core", async () => {
+      try {
+        await executeScenario(scenarioCore, strategy);
+      } catch (e) {
+        if (e != "done") {
+          await Promise.all([killSpeculos(), killAnvil()]);
+          throw e;
+        }
+      }
+    });
+
     it.skip("scenario scroll", async () => {
       try {
         await executeScenario(scenarioScroll);