LIVE-1004 Hedera integration

.ci.env

@@ -1,2 +1,3 @@
 DISABLE_MOCKED_WARNING=true
 EXPERIMENTAL_CURRENCIES_JS_BRIDGE=algorand,bitcoin,bitcoin_cash,bsc,litecoin,dash,qtum,zcash,bitcoin_gold,stratis,dogecoin,digibyte,komodo,pivx,zencash,vertcoin,peercoin,viacoin,stakenet,stealthcoin,decred,bitcoin_testnet,tezos,cosmos
+EXPERIMENTAL_CURRENCIES=hedera

.github/workflows/bot-hedera-mooncake.yml

@@ -0,0 +1,81 @@
+name: Bot 'Hedera'
+on:
+  push:
+    branches:
+      - family/hedera
+
+jobs:
+  start-runner:
+    name: "start ec2 instance (Linux)"
+    if: ${{ always() }}
+    uses: ledgerhq/actions/.github/workflows/start-linux-runner.yml@main
+    secrets:
+      CI_BOT_TOKEN: ${{ secrets.CI_BOT_TOKEN }}
+
+  stop-runner:
+    name: "stop ec2 instance (Linux)"
+    needs: [start-runner, run-bot]
+    uses: ledgerhq/actions/.github/workflows/stop-linux-runner.yml@main
+    if: ${{ always() }}
+    with:
+      label: ${{ needs.start-runner.outputs.label }}
+      ec2-instance-id: ${{ needs.start-runner.outputs.ec2-instance-id }}
+    secrets:
+      CI_BOT_TOKEN: ${{ secrets.CI_BOT_TOKEN }}
+
+  run-bot:
+    needs: [start-runner]
+    runs-on: ${{ needs.start-runner.outputs.label }}
+    steps:
+      - name: prepare runner
+        run: |
+          sudo growpart /dev/nvme0n1 1
+          sudo resize2fs /dev/nvme0n1p1
+      - uses: actions/checkout@v2
+      - name: Retrieving coin apps
+        uses: actions/checkout@v2
+        with:
+          repository: LedgerHQ/coin-apps
+          token: ${{ secrets.PAT }}
+          path: coin-apps
+      - uses: actions/setup-node@master
+        with:
+          node-version: 14.x
+      - name: install yarn
+        run: npm i -g yarn
+      - name: pull docker image
+        run: docker pull ghcr.io/ledgerhq/speculos
+      - name: kill apt-get
+        run: sudo killall -w apt-get apt || echo OK
+      - name: Install linux deps
+        run: sudo apt-get install -y libusb-1.0-0-dev jq
+      - name: Install dependencies
+        run: |
+          yarn global add yalc
+          yarn --frozen-lockfile
+          yarn ci-setup-cli
+      - name: BOT
+        env:
+          SHOW_LEGACY_NEW_ACCOUNT: "1"
+          DEBUG_HTTP_RESPONSE: "1"
+          SEED: ${{ secrets.SEED4 }}
+          VERBOSE_FILE: bot-tests.txt
+          GITHUB_SHA: ${GITHUB_SHA}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_RUN_ID: ${{ github.run_id }}
+          GITHUB_WORKFLOW: ${{ github.workflow }}
+          SLACK_API_TOKEN: ${{ secrets.SLACK_API_TOKEN }}
+          SLACK_CHANNEL: ci-hbar-ll
+          BOT_FILTER_FAMILY: hedera
+          EXPERIMENTAL_CURRENCIES: hedera
+        run: COINAPPS=$PWD/coin-apps yarn ci-test-bot
+        timeout-minutes: 120
+      - name: Run coverage
+        if: failure() || success()
+        run: CODECOV_TOKEN=${{ secrets.CODECOV_TOKEN }} npx codecov
+      - name: upload logs
+        if: failure() || success()
+        uses: actions/upload-artifact@v1
+        with:
+          name: bot-tests.txt
+          path: bot-tests.txt

cli/src/live-common-setup-base.ts

@@ -45,6 +45,7 @@ setSupportedCurrencies([
   "crypto_org",
   "crypto_org_croeseid",
   "celo",
+  "hedera",
 ]);
 
 for (const k in process.env) setEnvUnsafe(k as EnvName, process.env[k]);

package.json

@@ -51,6 +51,7 @@
     "@crypto-com/chain-jslib": "0.0.19",
     "@ethereumjs/common": "^2.6.2",
     "@ethereumjs/tx": "^3.5.0",
+    "@hashgraph/sdk": "^2.10.1",
     "@ledgerhq/compressjs": "1.3.2",
     "@ledgerhq/cryptoassets": "6.28.2",
     "@ledgerhq/devices": "6.27.1",

src/__tests__/test-helpers/setup.ts

@@ -58,4 +58,5 @@ setSupportedCurrencies([
   "filecoin",
   "solana",
   "celo",
+  "hedera",
 ]);

src/cross.ts

@@ -271,7 +271,7 @@ export function accountToAccountData({
   index,
   balance,
 }: Account): AccountData {
-  return {
+  const res: AccountData = {
     id,
     name,
     seedIdentifier,
@@ -281,6 +281,8 @@ export function accountToAccountData({
     index,
     balance: balance.toString(),
   };
+
+  return res;
 }
 // reverse the account data to an account.
 // this restore the essential data of an account and the result of the fields
@@ -358,5 +360,6 @@ export const accountDataToAccount = ({
     creationDate: new Date(),
     balanceHistoryCache: emptyHistoryCache,
   };
+
   return account;
 };

src/derivation.ts

@@ -164,6 +164,9 @@ const modes = Object.freeze({
   solanaSub: {
     overridesDerivation: "44'/501'/<account>'",
   },
+  hederaBip44: {
+    overridesDerivation: "44/3030",
+  },
 });
 modes as Record<DerivationMode, ModeSpec>; // eslint-disable-line
 
@@ -179,6 +182,7 @@ const legacyDerivations: Record<CryptoCurrencyIds, DerivationMode[]> = {
   stellar: ["sep5"],
   polkadot: ["polkadotbip44"],
   filecoin: ["filecoin"],
+  hedera: ["hederaBip44"],
 };
 
 const legacyDerivationsPerFamily: Record<string, DerivationMode[]> = {
@@ -338,11 +342,13 @@ const disableBIP44 = {
   stellar: true,
   polkadot: true,
   solana: true,
+  hedera: true,
 };
 const seedIdentifierPath = {
   neo: ({ purpose, coinType }) => `${purpose}'/${coinType}'/0'/0/0`,
   filecoin: ({ purpose, coinType }) => `${purpose}'/${coinType}'/0'/0/0`,
   solana: ({ purpose, coinType }) => `${purpose}'/${coinType}'`,
+  hedera: ({ purpose, coinType }) => `${purpose}/${coinType}`,
   _: ({ purpose, coinType }) => `${purpose}'/${coinType}'/0'`,
 };
 export const getSeedIdentifierDerivation = (

src/env.ts

@@ -140,6 +140,11 @@ const envDefinitions = {
     def: "https://validators-solana.coin.ledger.com/api/v1/validators",
     desc: "base url for validators.app validator list",
   },
+  API_HEDERA_MIRROR: {
+    def: "https://hedera.coin.ledger.com",
+    parser: stringParser,
+    desc: "mirror node API for Hedera",
+  },
   BASE_SOCKET_URL: {
     def: "wss://scriptrunner.api.live.ledger.com/update",
     parser: stringParser,

src/families/hedera/api/mirror.ts

@@ -0,0 +1,151 @@
+import BigNumber from "bignumber.js";
+import network from "../../../network";
+import URL from "url";
+import { getAccountBalance } from "./network";
+import { Operation, OperationType } from "../../../types";
+import { encodeOperationId } from "../../../operation";
+import { AccountId } from "@hashgraph/sdk";
+import { getEnv } from "../../../env";
+import { base64ToUrlSafeBase64 } from "../utils";
+
+const getMirrorApiUrl = (): string => getEnv("API_HEDERA_MIRROR");
+
+const fetch = (path, query = {}) =>
+  network({
+    type: "get",
+    url: URL.format({
+      pathname: `${getMirrorApiUrl()}/api/v1${path}`,
+      query,
+    }),
+  });
+
+export interface Account {
+  accountId: AccountId;
+  balance: BigNumber;
+}
+
+export async function getAccountsForPublicKey(
+  publicKey: string
+): Promise<Account[]> {
+  let r;
+  try {
+    r = await fetch("/accounts", {
+      "account.publicKey": publicKey,
+      balance: false,
+    });
+  } catch (e: any) {
+    if (e.name === "LedgerAPI4xx") return [];
+    throw e;
+  }
+  const rawAccounts = r.data.accounts;
+  const accounts: Account[] = [];
+
+  for (const raw of rawAccounts) {
+    const accountBalance = await getAccountBalance(raw.account);
+
+    accounts.push({
+      accountId: AccountId.fromString(raw.account),
+      balance: accountBalance.balance,
+    });
+  }
+
+  return accounts;
+}
+
+interface HederaMirrorTransaction {
+  transfers: HederaMirrorTransfer[];
+  charged_tx_fee: string;
+  transaction_hash: string;
+  consensus_timestamp: string;
+}
+
+interface HederaMirrorTransfer {
+  account: string;
+  amount: number;
+}
+
+export async function getOperationsForAccount(
+  ledgerAccountId: string,
+  address: string,
+  latestOperationTimestamp: string
+): Promise<Operation[]> {
+  const operations: Operation[] = [];
+  const r = await fetch("/transactions", {
+    "account.id": address,
+    timestamp: `gt:${latestOperationTimestamp}`,
+  });
+  const rawOperations = r.data.transactions as HederaMirrorTransaction[];
+
+  for (const raw of rawOperations) {
+    const { consensus_timestamp } = raw;
+    const timestamp = new Date(
+      parseInt(consensus_timestamp.split(".")[0], 10) * 1000
+    );
+    const senders: string[] = [];
+    const recipients: string[] = [];
+    const fee = new BigNumber(raw.charged_tx_fee);
+    let value = new BigNumber(0);
+    let type: OperationType = "NONE";
+
+    for (let i = raw.transfers.length - 1; i >= 0; i--) {
+      const transfer = raw.transfers[i];
+      const amount = new BigNumber(transfer.amount);
+      const account = AccountId.fromString(transfer.account);
+
+      if (transfer.account === address) {
+        if (amount.isNegative()) {
+          value = amount.abs();
+          type = "OUT";
+        } else {
+          value = amount;
+          type = "IN";
+        }
+      }
+
+      if (amount.isNegative()) {
+        senders.push(transfer.account);
+      } else {
+        if (account.shard.eq(0) && account.realm.eq(0)) {
+          if (account.num.lt(100)) {
+            // account is a node, only add to list if we have none
+            if (recipients.length === 0) {
+              recipients.push(transfer.account);
+            }
+          } else if (account.num.lt(1000)) {
+            // account is a system account that is not a node
+            // do NOT add
+          } else {
+            recipients.push(transfer.account);
+          }
+        } else {
+          recipients.push(transfer.account);
+        }
+      }
+    }
+
+    // NOTE: earlier addresses are the "fee" addresses
+    recipients.reverse();
+    senders.reverse();
+
+    const hash = base64ToUrlSafeBase64(raw.transaction_hash);
+
+    operations.push({
+      value,
+      date: timestamp,
+      // NOTE: there are no "blocks" in hedera
+      // Set a value just so that it's considered confirmed according to isConfirmedOperation
+      blockHeight: 5,
+      blockHash: null,
+      extra: { consensus_timestamp },
+      fee,
+      hash,
+      recipients,
+      senders,
+      accountId: ledgerAccountId,
+      id: encodeOperationId(ledgerAccountId, hash, type),
+      type,
+    });
+  }
+
+  return operations;
+}

src/families/hedera/api/network.ts

@@ -0,0 +1,56 @@
+import BigNumber from "bignumber.js";
+import * as hedera from "@hashgraph/sdk";
+import { Account } from "../../../types";
+import { Transaction } from "../types";
+import { AccountId } from "@hashgraph/sdk";
+
+export function broadcastTransaction(
+  transaction: hedera.Transaction
+): Promise<hedera.TransactionResponse> {
+  return transaction.execute(getClient());
+}
+
+export async function buildUnsignedTransaction({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<hedera.TransferTransaction> {
+  const hbarAmount = hedera.Hbar.fromTinybars(transaction.amount);
+  const accountId = account.freshAddress;
+
+  return new hedera.TransferTransaction()
+    .setNodeAccountIds([new AccountId(3)])
+    .setTransactionId(hedera.TransactionId.generate(accountId))
+    .addHbarTransfer(accountId, hbarAmount.negated())
+    .addHbarTransfer(transaction.recipient, hbarAmount)
+    .freeze();
+}
+
+export interface AccountBalance {
+  balance: BigNumber;
+}
+
+export async function getAccountBalance(
+  address: string
+): Promise<AccountBalance> {
+  const accountId = AccountId.fromString(address);
+  const accountBalance = await new hedera.AccountBalanceQuery({
+    accountId,
+  }).execute(getClient());
+
+  return {
+    balance: accountBalance.hbars.to(hedera.HbarUnit.Tinybar),
+  };
+}
+
+let _hederaClient: hedera.Client | null = null;
+
+function getClient(): hedera.Client {
+  _hederaClient ??= hedera.Client.forMainnet().setMaxNodesPerTransaction(1);
+
+  //_hederaClient.setNetwork({ mainnet: "https://hedera.coin.ledger.com" });
+
+  return _hederaClient;
+}