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

package/src/families/tron/synchronization.ts

@@ -0,0 +1,270 @@
+import get from "lodash/get";
+import compact from "lodash/compact";
+import BigNumber from "bignumber.js";
+import {
+  emptyHistoryCache,
+  encodeAccountId,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+import { SubAccount, TokenAccount } from "@ledgerhq/types-live";
+import { GetAccountShape, makeSync } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { findTokenByAddressInCurrency, findTokenById } from "@ledgerhq/cryptoassets/tokens";
+import { TronAccount, TronOperation, TrongridExtraTxInfo } from "./types";
+import { getOperationsPageSize } from "../../pagination";
+import { isParentTx, txInfoToOperation } from "./utils";
+import { encodeOperationId } from "../../operation";
+import {
+  fetchCurrentBlockHeight,
+  fetchTronAccount,
+  fetchTronAccountTxs,
+  getTronResources,
+} from "./api";
+
+// the balance does not update straightaway so we should ignore recent operations if they are in pending for a bit
+const PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION = 35;
+
+export const getAccountShape: GetAccountShape<TronAccount> = async (
+  { initialAccount, currency, address, derivationMode },
+  syncConfig,
+) => {
+  const blockHeight = await fetchCurrentBlockHeight();
+  const tronAcc = await fetchTronAccount(address);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode: derivationMode,
+  });
+
+  if (tronAcc.length === 0) {
+    const defaultTronResources = await getTronResources();
+
+    return {
+      id: accountId,
+      blockHeight,
+      balance: new BigNumber(0),
+      tronResources: defaultTronResources,
+    };
+  }
+
+  const acc = tronAcc[0];
+  const spendableBalance = acc.balance ? new BigNumber(acc.balance) : new BigNumber(0);
+  const cacheTransactionInfoById = initialAccount
+    ? {
+        ...(initialAccount?.tronResources?.cacheTransactionInfoById || {}),
+      }
+    : {};
+  const operationsPageSize = Math.min(
+    1000,
+    getOperationsPageSize(initialAccount && initialAccount.id, syncConfig),
+  );
+  // FIXME: this is not optional especially that we might already have initialAccount
+  // use minimalOperationsBuilderSync to reconciliate and KEEP REF
+  const txs = await fetchTronAccountTxs(
+    address,
+    txs => txs.length < operationsPageSize,
+    cacheTransactionInfoById,
+  );
+
+  const tronResources = await getTronResources(acc, txs, cacheTransactionInfoById);
+  const balance = spendableBalance
+    .plus(tronResources.frozen.bandwidth ? tronResources.frozen.bandwidth.amount : new BigNumber(0))
+    .plus(tronResources.frozen.energy ? tronResources.frozen.energy.amount : new BigNumber(0))
+    .plus(
+      tronResources.delegatedFrozen.bandwidth
+        ? tronResources.delegatedFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.delegatedFrozen.energy
+        ? tronResources.delegatedFrozen.energy.amount
+        : new BigNumber(0),
+    )
+
+    .plus(
+      tronResources.unFrozen.energy
+        ? tronResources.unFrozen.energy.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.unFrozen.bandwidth
+        ? tronResources.unFrozen.bandwidth.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.bandwidth
+        ? tronResources.legacyFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.energy
+        ? tronResources.legacyFrozen.energy.amount
+        : new BigNumber(0),
+    );
+
+  const parentTxs = txs.filter(isParentTx);
+  const parentOperations: TronOperation[] = compact(
+    parentTxs.map(tx => txInfoToOperation(accountId, address, tx)),
+  );
+
+  const trc10Tokens = get(acc, "assetV2", []).reduce((accumulator, { key, value }) => {
+    const tokenInfo = findTokenById(`tron/trc10/${key}`);
+    if (tokenInfo) {
+      accumulator.push({
+        key,
+        type: "trc10",
+        tokenId: tokenInfo.id,
+        balance: value,
+      });
+    }
+    return accumulator;
+  }, []);
+
+  const trc20Tokens = get(acc, "trc20", []).reduce((accumulator, trc20) => {
+    const [[contractAddress, balance]] = Object.entries(trc20);
+    const tokenInfo = findTokenByAddressInCurrency(contractAddress, currency.id);
+    if (tokenInfo) {
+      accumulator.push({
+        key: contractAddress,
+        type: "trc20",
+        tokenId: tokenInfo.id,
+        balance,
+      });
+    }
+    return accumulator;
+  }, []);
+
+  const { blacklistedTokenIds = [] } = syncConfig;
+
+  const subAccounts: SubAccount[] = compact(
+    trc10Tokens.concat(trc20Tokens).map(({ key, tokenId, balance }) => {
+      const token = findTokenById(tokenId);
+      if (!token || blacklistedTokenIds.includes(tokenId)) return;
+      const id = encodeTokenAccountId(accountId, token);
+      const tokenTxs = txs.filter(tx => tx.tokenId === key);
+      const operations = compact(tokenTxs.map(tx => txInfoToOperation(id, address, tx)));
+      const maybeExistingSubAccount = initialAccount?.subAccounts?.find(a => a.id === id);
+      const bnBalance = new BigNumber(balance);
+      const sub: TokenAccount = {
+        type: "TokenAccount",
+        id,
+        parentId: accountId,
+        token,
+        balance: bnBalance,
+        spendableBalance: bnBalance,
+        operationsCount: operations.length,
+        operations,
+        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
+        creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+      };
+      return sub;
+    }),
+  );
+
+  // Filter blacklisted tokens from the initial account's subAccounts
+  // Could be use to filter out tokens that got their CAL id changed
+  const filteredInitialSubAccounts = (initialAccount?.subAccounts || []).filter(
+    subAccount => !blacklistedTokenIds.includes(subAccount.token.id),
+  );
+
+  // keep old account with emptyBalance and a history not returned by the BE fixes LIVE-12797
+  const mergedSubAccounts = mergeSubAccounts(subAccounts, filteredInitialSubAccounts);
+
+  // get 'OUT' token operations with fee
+  const subOutOperationsWithFee: TronOperation[] = subAccounts
+    .flatMap(s => s.operations)
+    .filter(o => o.type === "OUT" && o.fee.isGreaterThan(0))
+    .map(
+      (o): TronOperation => ({
+        ...o,
+        accountId,
+        value: o.fee,
+        id: encodeOperationId(accountId, o.hash, "OUT"),
+        extra: o.extra as TrongridExtraTxInfo,
+      }),
+    );
+  // add them to the parent operations and sort by date desc
+
+  /**
+   * FIXME
+   *
+   * We have a problem here as we're just concatenating ops without ever really linking them.
+   * It means no operation can be "FEES" of a subOp by example. It leads to our issues with TRC10/TRC20
+   * optimistic operation never really existing in the end.
+   */
+  const parentOpsAndSubOutOpsWithFee = parentOperations
+    .concat(subOutOperationsWithFee)
+    .sort((a, b) => b.date.valueOf() - a.date.valueOf());
+
+  return {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: parentOpsAndSubOutOpsWithFee.length,
+    operations: parentOpsAndSubOutOpsWithFee,
+    subAccounts: mergedSubAccounts,
+    tronResources,
+    blockHeight,
+  };
+};
+
+export const postSync = (initial: TronAccount, parent: TronAccount): TronAccount => {
+  function evictRecentOpsIfPending(a) {
+    a.pendingOperations.forEach(pending => {
+      const i = a.operations.findIndex(o => o.id === pending.id);
+
+      if (i !== -1) {
+        const diff = parent.blockHeight - (a.operations[i].blockHeight || 0);
+
+        if (diff < PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION) {
+          a.operations.splice(i, 1);
+        }
+      }
+    });
+  }
+
+  evictRecentOpsIfPending(parent);
+  parent.subAccounts && parent.subAccounts.forEach(evictRecentOpsIfPending);
+  return parent;
+};
+
+/**
+ * Merges two arrays of subAccounts according to specific rules:
+ * - The first array (subAccounts1) is up-to-date and should not be modified.
+ * - Old duplicates from the second array (subAccounts2) should be filtered out.
+ * - Only new subAccounts with a unique ID from the second array should be included.
+ * - The balance and spendableBalance fields of the second array's subAccounts should be set to 0.
+ *
+ * @param {Array} subAccounts1 - The first array of subAccounts, which is up-to-date and should not be modified.
+ * @param {Array} subAccounts2 - The second array of subAccounts, from which only new unique subAccounts should be included.
+ * @returns {Array} - The merged array of subAccounts.
+ */
+const mergeSubAccounts = (subAccounts1, subAccounts2) => {
+  const existingIds = new Set(subAccounts1.map(subAccount => subAccount.id));
+  const filteredSubAccounts2 = subAccounts2
+    .map(subAccount => {
+      if (existingIds.has(subAccount.id)) {
+        return null;
+      } else {
+        // Set balance and spendableBalance to 0 has if they are not here it means balance is 0
+        return {
+          ...subAccount,
+          balance: new BigNumber(0),
+          spendableBalance: new BigNumber(0),
+        };
+      }
+    })
+    .filter(subAccount => subAccount !== null);
+
+  return subAccounts1.concat(filteredSubAccounts2);
+};
+
+export const sync = makeSync({ getAccountShape, postSync });

package/src/families/tron/transaction.ts

@@ -1,14 +1,14 @@
 import { BigNumber } from "bignumber.js";
 import type { Transaction, TransactionRaw } from "./types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
 import {
-  formatTransactionStatusCommon as formatTransactionStatus,
   fromTransactionCommonRaw,
   fromTransactionStatusRawCommon as fromTransactionStatusRaw,
   toTransactionCommonRaw,
   toTransactionStatusRawCommon as toTransactionStatusRaw,
-} from "@ledgerhq/coin-framework/transaction/common";
+} from "@ledgerhq/coin-framework/serialization";
 import type { Account } from "@ledgerhq/types-live";
-import { getAccountUnit } from "../../account";
+import { getAccountCurrency } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 
 export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
@@ -64,12 +64,12 @@ ${t.mode.toUpperCase()}${t.resource ? " " + t.resource : ""} ${
     t.useAllAmount
       ? "MAX"
       : t.amount.isZero()
-      ? ""
-      : " " +
-        formatCurrencyUnit(getAccountUnit(account), t.amount, {
-          showCode: true,
-          disableRounding: true,
-        })
+        ? ""
+        : " " +
+          formatCurrencyUnit(getAccountCurrency(account).units[0], t.amount, {
+            showCode: true,
+            disableRounding: true,
+          })
   }${!t.votes ? "" : " " + t.votes.map(v => v.voteCount + "->" + v.address).join(" ")}
 TO ${t.recipient}`;
 };

package/src/families/tron/types.ts

@@ -212,7 +212,7 @@ export type TronResources = {
   unwithdrawnReward: BigNumber;
   lastWithdrawnRewardDate: Date | null | undefined;
   lastVotedDate: Date | null | undefined;
-  cacheTransactionInfoById: Record<string, TronTransactionInfo>;
+  cacheTransactionInfoById: Record<string, TronTransactionInfo> | undefined;
 };
 export type TronResourcesRaw = {
   frozen: {
@@ -238,7 +238,7 @@ export type TronResourcesRaw = {
   unwithdrawnReward: string;
   lastWithdrawnRewardDate: string | null | undefined;
   lastVotedDate: string | null | undefined;
-  cacheTransactionInfoById?: Record<string, TronTransactionInfoRaw>;
+  cacheTransactionInfoById: Record<string, TronTransactionInfoRaw> | undefined;
 };
 export type Vote = {
   address: string;

package/src/families/tron/utils.ts

@@ -2,7 +2,6 @@ import bs58check from "bs58check";
 import { BigNumber } from "bignumber.js";
 import get from "lodash/get";
 import { log } from "@ledgerhq/logs";
-import { extractBandwidthInfo } from "./api";
 import type {
   Transaction,
   TronOperationMode,
@@ -10,6 +9,8 @@ import type {
   TrongridExtraTxInfo,
   TronResources,
   TronOperation,
+  BandwidthInfo,
+  NetworkInfo,
 } from "./types";
 import type { Account, OperationType } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
@@ -202,8 +203,8 @@ export const formatTrongridTxResponse = (
       type === "TransferAssetContract"
         ? asset_name
         : type === "TriggerSmartContract" && contract_address
-        ? encode58Check(contract_address)
-        : undefined;
+          ? encode58Check(contract_address)
+          : undefined;
     const from = encode58Check(owner_address);
     const to = to_address ? encode58Check(to_address) : undefined;
 
@@ -328,6 +329,28 @@ export const txInfoToOperation = (
   return undefined;
 };
 
+export const extractBandwidthInfo = (
+  networkInfo: NetworkInfo | null | undefined,
+): BandwidthInfo => {
+  // Calculate bandwidth info :
+  if (networkInfo) {
+    const { freeNetUsed, freeNetLimit, netUsed, netLimit } = networkInfo;
+    return {
+      freeUsed: freeNetUsed,
+      freeLimit: freeNetLimit,
+      gainedUsed: netUsed,
+      gainedLimit: netLimit,
+    };
+  }
+
+  return {
+    freeUsed: new BigNumber(0),
+    freeLimit: new BigNumber(0),
+    gainedUsed: new BigNumber(0),
+    gainedLimit: new BigNumber(0),
+  };
+};
+
 export const defaultTronResources: TronResources = {
   frozen: {
     bandwidth: undefined,

package/src/families/vechain/__snapshots__/bridge.integration.test.ts.snap

@@ -8,33 +8,21 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "feesCurrencyId": "vechain/vip180/vtho",
     "freshAddress": "0x0fe6688548f0C303932bB197B0A96034f1d74dba",
     "freshAddressPath": "44'/818'/0'/0/0",
-    "freshAddresses": [
-      {
-        "address": "0x0fe6688548f0C303932bB197B0A96034f1d74dba",
-        "derivationPath": "44'/818'/0'/0/0",
-      },
-    ],
     "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
     "index": 0,
-    "name": "Vechain 1",
-    "nfts": undefined,
     "operationsCount": 1,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
-    "starred": false,
     "subAccounts": [],
     "swapHistory": [],
     "syncHash": undefined,
-    "unitMagnitude": 18,
     "used": true,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 1,
     "parentId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
     "pendingOperations": [],
-    "starred": false,
     "swapHistory": [],
     "tokenId": "vechain/vip180/vtho",
     "type": "TokenAccountRaw",
@@ -45,33 +33,21 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "feesCurrencyId": "vechain/vip180/vtho",
     "freshAddress": "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86",
     "freshAddressPath": "44'/818'/0'/0/1",
-    "freshAddresses": [
-      {
-        "address": "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86",
-        "derivationPath": "44'/818'/0'/0/1",
-      },
-    ],
     "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
     "index": 1,
-    "name": "Vechain 2",
-    "nfts": undefined,
     "operationsCount": 1,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
-    "starred": false,
     "subAccounts": [],
     "swapHistory": [],
     "syncHash": undefined,
-    "unitMagnitude": 18,
     "used": true,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 0,
     "parentId": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
     "pendingOperations": [],
-    "starred": false,
     "swapHistory": [],
     "tokenId": "vechain/vip180/vtho",
     "type": "TokenAccountRaw",
@@ -82,33 +58,21 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "feesCurrencyId": "vechain/vip180/vtho",
     "freshAddress": "0xFbC8653C0b842dd33361CE8938B24e407dd4838C",
     "freshAddressPath": "44'/818'/0'/0/2",
-    "freshAddresses": [
-      {
-        "address": "0xFbC8653C0b842dd33361CE8938B24e407dd4838C",
-        "derivationPath": "44'/818'/0'/0/2",
-      },
-    ],
     "id": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain",
     "index": 2,
-    "name": "Vechain 3",
-    "nfts": undefined,
     "operationsCount": 0,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
-    "starred": false,
     "subAccounts": [],
     "swapHistory": [],
     "syncHash": undefined,
-    "unitMagnitude": 18,
     "used": false,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 0,
     "parentId": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain",
     "pendingOperations": [],
-    "starred": false,
     "swapHistory": [],
     "tokenId": "vechain/vip180/vtho",
     "type": "TokenAccountRaw",
@@ -123,20 +87,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
       "blockHash": "0x00fa5b35f158cee280b6be35b4ada7669951035a79806244aaa11e5d2764d5bd",
       "blockHeight": 16407349,
-      "contract": undefined,
       "extra": {},
       "fee": "210000000000000000",
       "hash": "0xe113f82af98a24c6f2473802f8673f0d69eed1c0f51a5a87d3cc6b8cf96ccfd6",
       "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain-0xe113f82af98a24c6f2473802f8673f0d69eed1c0f51a5a87d3cc6b8cf96ccfd6-IN",
-      "operator": undefined,
       "recipients": [
         "0x0fe6688548f0c303932bb197b0a96034f1d74dba",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },
@@ -146,20 +106,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
       "blockHash": "0x00fa5b4ee2eca5cf65907e3695bbea044cd1f78224534dc0ba02526890055ecc",
       "blockHeight": 16407374,
-      "contract": undefined,
       "extra": {},
       "fee": "365180000000000000",
       "hash": "0x5fdd7191c4d476a8e86060d516366e87421f65667b9b3c14c33a740c04921b10",
       "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho-0x5fdd7191c4d476a8e86060d516366e87421f65667b9b3c14c33a740c04921b10-IN",
-      "operator": undefined,
       "recipients": [
         "0x0fe6688548f0c303932bb197b0a96034f1d74dba",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },
@@ -169,20 +125,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
       "blockHash": "0x00fa5b547b0d542ba8e62a85aa99cf355f1b2a70bd34e3949f889b0856776e05",
       "blockHeight": 16407380,
-      "contract": undefined,
       "extra": {},
       "fee": "210000000000000000",
       "hash": "0xa4096186f2d58ecc68e6ea11c9757ef5bd78b21b87d73b4618eb6fd3508431ec",
       "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain-0xa4096186f2d58ecc68e6ea11c9757ef5bd78b21b87d73b4618eb6fd3508431ec-IN",
-      "operator": undefined,
       "recipients": [
         "0x02961b92b8d20a4ea12f1f1cefa74dd7b4355a86",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },

package/src/families/vechain/account.ts

@@ -1,9 +1,9 @@
 import type { Account } from "@ledgerhq/types-live";
-import { getAccountUnit } from "../../account";
+import { getAccountCurrency } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 
 function formatAccountSpecifics(account: Account): string {
-  const unit = getAccountUnit(account);
+  const unit = getAccountCurrency(account).units[0];
   const formatConfig = {
     disableRounding: true,
     alwaysShowSign: false,

package/src/families/vechain/api/index.ts

@@ -1,3 +1,2 @@
-import { getAccount, getOperations } from "./sdk";
+export { getAccount, getOperations } from "./sdk";
 export * from "./sdk";
-export default { getAccount, getOperations };

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

@@ -1,14 +1,14 @@
-import type { Transaction } from "../types";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-
-import { sync, scanAccounts } from "../js-synchronisation";
-import { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import { createTransaction, prepareTransaction } from "../js-transaction";
-import getTransactionStatus from "../js-getTransactionStatus";
-import signOperation from "../js-signOperation";
-import broadcast from "../js-broadcast";
-import { estimateMaxSpendable } from "./js-estimateMaxSpendable";
+import { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { getTransactionStatus } from "../getTransactionStatus";
+import type { Transaction, TransactionStatus } from "../types";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
+import { sync, scanAccounts } from "../synchronisation";
+import { signOperation } from "../signOperation";
+import { broadcast } from "../broadcast";
 
 const receive: AccountBridge<Transaction>["receive"] = makeAccountBridgeReceive();
 
@@ -18,7 +18,7 @@ const currencyBridge: CurrencyBridge = {
   hydrate: (): void => {},
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   estimateMaxSpendable,
   createTransaction,
   updateTransaction: defaultUpdateTransaction,

package/src/families/vechain/broadcast.ts

@@ -0,0 +1,22 @@
+import { Transaction as VeChainThorTransaction } from "thor-devkit";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "../../operation";
+import { Transaction } from "./types";
+import { submit } from "./api";
+
+/**
+ * Broadcast the signed transaction
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation, rawData },
+}) => {
+  const transaction = new VeChainThorTransaction(
+    (rawData as unknown as VeChainThorTransaction).body,
+  );
+  transaction.signature = Buffer.from(signature, "hex");
+  const hash = await submit(transaction);
+
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/families/vechain/buildOptimisticOperatioin.ts

@@ -0,0 +1,46 @@
+import { Account, Operation } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import { encodeOperationId } from "../../operation";
+import BigNumber from "bignumber.js";
+
+export const buildOptimisticOperation = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<Operation> => {
+  const TYPE_OUT = "OUT";
+  const subAccountId = transaction.subAccountId;
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", TYPE_OUT),
+    hash: "",
+    type: subAccountId ? "NONE" : TYPE_OUT,
+    value: subAccountId ? new BigNumber(0) : new BigNumber(transaction.amount),
+    fee: subAccountId ? new BigNumber(0) : new BigNumber(transaction.estimatedFees),
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    date: new Date(),
+    extra: {},
+    subOperations: subAccountId
+      ? [
+          {
+            id: encodeOperationId(subAccountId, "", "OUT"),
+            hash: "",
+            type: "OUT",
+            value: transaction.amount,
+            fee: subAccountId ? new BigNumber(transaction.estimatedFees) : new BigNumber(0),
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient].filter(Boolean),
+            accountId: subAccountId,
+            date: new Date(),
+            extra: {},
+          },
+        ]
+      : [],
+  };
+
+  return operation;
+};