@ledgerhq/coin-hedera 1.15.0-nightly.20251126023856 → 1.15.0-nightly.20251127023715

package/src/network/utils.ts

@@ -1,7 +1,18 @@
 import BigNumber from "bignumber.js";
 import { AccountId } from "@hashgraph/sdk";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
-import type { HederaMirrorTokenTransfer, HederaMirrorCoinTransfer } from "../types";
+import { apiClient } from "./api";
+import type {
+  HederaMirrorTokenTransfer,
+  HederaMirrorCoinTransfer,
+  HederaThirdwebTransaction,
+  HederaThirdwebDecodedTransferParams,
+  OperationERC20,
+  HederaERC20TokenBalance,
+} from "../types";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { SUPPORTED_ERC20_TOKENS } from "../constants";
 
 function isValidRecipient(accountId: AccountId, recipients: string[]): boolean {
   if (accountId.shard.eq(0) && accountId.realm.eq(0)) {
@@ -56,3 +67,74 @@ export function parseTransfers(
     recipients,
   };
 }
+
+export async function getERC20BalancesForAccount(
+  evmAccountId: string,
+  supportedTokenIds = SUPPORTED_ERC20_TOKENS.map(token => token.id),
+): Promise<HederaERC20TokenBalance[]> {
+  const availableTokens: TokenCurrency[] = [];
+
+  for (const erc20TokenId of supportedTokenIds) {
+    const calToken = await getCryptoAssetsStore().findTokenById(erc20TokenId);
+
+    if (calToken) {
+      availableTokens.push(calToken);
+    }
+  }
+
+  const promises = availableTokens.map(async erc20token => {
+    const balance = await apiClient.getERC20Balance(evmAccountId, erc20token.contractAddress);
+
+    return {
+      balance,
+      token: erc20token,
+    };
+  });
+
+  const balances = await Promise.all(promises);
+
+  return balances;
+}
+
+export const getERC20Operations = async (
+  latestERC20Transactions: HederaThirdwebTransaction[],
+): Promise<OperationERC20[]> => {
+  const latestERC20Operations: OperationERC20[] = [];
+
+  for (const thirdwebTransaction of latestERC20Transactions) {
+    const tokenId = thirdwebTransaction.address;
+    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(tokenId, "hedera");
+
+    if (!token) continue;
+
+    const hash = thirdwebTransaction.transactionHash;
+    const contractCallResult = await apiClient.getContractCallResult(hash);
+    const mirrorTransaction = await apiClient.findTransactionByContractCall(
+      contractCallResult.timestamp,
+      contractCallResult.contract_id,
+    );
+
+    if (!mirrorTransaction) continue;
+
+    latestERC20Operations.push({
+      thirdwebTransaction,
+      mirrorTransaction,
+      contractCallResult,
+      token,
+    });
+  }
+
+  return latestERC20Operations;
+};
+
+export function parseThirdwebTransactionParams(
+  transaction: HederaThirdwebTransaction,
+): HederaThirdwebDecodedTransferParams | null {
+  const { from, to, value } = transaction.decoded.params;
+
+  if (typeof from !== "string" || typeof to !== "string" || typeof value !== "string") {
+    return null;
+  }
+
+  return { from, to, value };
+}

package/src/test/bridgeDatasetTest.ts

@@ -5,7 +5,6 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
 } from "@ledgerhq/errors";
-
 import { HEDERA_TRANSACTION_MODES } from "../constants";
 import { fromTransactionRaw } from "../transaction";
 import type { Transaction } from "../types";
@@ -42,10 +41,10 @@ export const hedera: CurrenciesData<Transaction> = {
         {
           name: "Recipient and sender must not be the same",
           transaction: fromTransactionRaw({
+            mode: HEDERA_TRANSACTION_MODES.Send,
             family: "hedera",
             recipient: "0.0.751515",
             amount: "100000000",
-            mode: HEDERA_TRANSACTION_MODES.Send,
           }),
           expectedStatus: {
             errors: {
@@ -57,10 +56,10 @@ export const hedera: CurrenciesData<Transaction> = {
         {
           name: "Amount Required",
           transaction: fromTransactionRaw({
+            mode: HEDERA_TRANSACTION_MODES.Send,
             family: "hedera",
             recipient: "0.0.751515",
             amount: "0",
-            mode: HEDERA_TRANSACTION_MODES.Send,
           }),
           expectedStatus: {
             errors: {
@@ -72,10 +71,10 @@ export const hedera: CurrenciesData<Transaction> = {
         {
           name: "Not enough balance",
           transaction: fromTransactionRaw({
+            mode: HEDERA_TRANSACTION_MODES.Send,
             family: "hedera",
             recipient: "0.0.751515",
             amount: "1000000000000000",
-            mode: HEDERA_TRANSACTION_MODES.Send,
           }),
           expectedStatus: {
             errors: {
@@ -87,10 +86,10 @@ export const hedera: CurrenciesData<Transaction> = {
         {
           name: "Send max",
           transaction: fromTransactionRaw({
+            mode: HEDERA_TRANSACTION_MODES.Send,
             family: "hedera",
             recipient: "0.0.751515",
             amount: "1000000000000000",
-            mode: HEDERA_TRANSACTION_MODES.Send,
             useAllAmount: true,
           }),
           expectedStatus: (account, _, status) => {

package/src/test/fixtures/account.fixture.ts

@@ -6,11 +6,11 @@ import type {
   HederaResourcesRaw,
 } from "../../types";
 import type { TokenAccount } from "@ledgerhq/types-live";
-import { getMockedCurrency, getMockedTokenCurrency } from "./currency.fixture";
+import { getMockedCurrency, getMockedHTSTokenCurrency } from "./currency.fixture";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 const defaultMockedCurrency = getMockedCurrency();
-const defaultMockedTokenCurrency = getMockedTokenCurrency();
+const defaultMockedTokenCurrency = getMockedHTSTokenCurrency();
 const defaultMockAccountId = "js:2:hedera:0.0.1234567:hederaBip44";
 const defaultMockTokenAccountId = `${defaultMockAccountId}+${defaultMockedTokenCurrency.id}`;
 const defaultBalance = new BigNumber(100000000);

package/src/test/fixtures/common.fixture.ts

@@ -0,0 +1,74 @@
+import BigNumber from "bignumber.js";
+import type network from "@ledgerhq/live-network";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getMockedThirdwebTransaction } from "./thirdweb.fixture";
+import type { ERC20OperationFields, OperationERC20 } from "../../types";
+
+export const getMockResponse = (data: unknown): Awaited<ReturnType<typeof network>> => ({
+  data,
+  status: 200,
+});
+
+export const getMockERC20Operation = ({
+  hash,
+  from,
+  to,
+  token,
+}: {
+  hash: string;
+  from: string;
+  to: string;
+  token: TokenCurrency;
+}): OperationERC20 => ({
+  thirdwebTransaction: getMockedThirdwebTransaction({
+    transactionHash: hash,
+    blockHash: "0xBLOCK",
+    decoded: {
+      name: "Transfer",
+      signature: "Transfer(address,address,uint256)",
+      params: {
+        from,
+        to,
+        value: "1000000",
+      },
+    },
+  }),
+  mirrorTransaction: {
+    transaction_hash: hash,
+    consensus_timestamp: "1234567890.000000000",
+    transaction_id: "0.0.123@1234567890.000",
+    charged_tx_fee: 100000,
+    memo_base64: "",
+  } as any,
+  contractCallResult: {
+    timestamp: "1234567890.000000000",
+    contract_id: "0.0.TOKEN",
+    gas_consumed: 50000,
+    gas_limit: 100000,
+    gas_used: 50000,
+  } as any,
+  token,
+});
+
+export const getMockERC20Fields = (
+  overrides?: Partial<ERC20OperationFields>,
+): ERC20OperationFields => ({
+  date: new Date("2024-01-15T10:00:00Z"),
+  type: "OUT",
+  fee: new BigNumber(100000),
+  value: new BigNumber(1000000),
+  senders: ["0.0.SENDER"],
+  recipients: ["0.0.RECIPIENT"],
+  blockHeight: 12345,
+  blockHash: "0xBLOCK",
+  extra: {
+    consensusTimestamp: "1234567890.000000000",
+    transactionId: "0.0.123@1234567890.000",
+    gasConsumed: 50000,
+    gasLimit: 100000,
+    gasUsed: 50000,
+  },
+  standard: "erc20",
+  hasFailed: false,
+  ...overrides,
+});

package/src/test/fixtures/currency.fixture.ts

@@ -32,11 +32,11 @@ export const getMockedCurrency = (overrides?: Partial<CryptoCurrency>): CryptoCu
 const HARDCODED_HEDERA_TOKENS: TokenCurrency[] = [
   {
     type: "TokenCurrency",
-    id: "hedera/hts/0.0.456858",
+    id: "hedera/hts/usd_coin_0.0.456858",
     contractAddress: "0.0.456858",
     parentCurrency: getMockedCurrency(),
     tokenType: "hts",
-    name: "USDC",
+    name: "USD Coin",
     ticker: "USDC",
     delisted: false,
     disableCountervalue: false,
@@ -50,19 +50,37 @@ const HARDCODED_HEDERA_TOKENS: TokenCurrency[] = [
   },
   {
     type: "TokenCurrency",
-    id: "hedera/hts/0.0.7243470",
+    id: "hedera/hts/xpack_0.0.7243470",
     contractAddress: "0.0.7243470",
     parentCurrency: getMockedCurrency(),
     tokenType: "hts",
-    name: "HBARX",
-    ticker: "HBARX",
+    name: "xPACK",
+    ticker: "XPACK",
     delisted: false,
     disableCountervalue: false,
     units: [
       {
-        name: "HBARX",
-        code: "HBARX",
-        magnitude: 8,
+        name: "XPACK",
+        code: "XPACK",
+        magnitude: 6,
+      },
+    ],
+  },
+  {
+    type: "TokenCurrency",
+    id: "hedera/erc20/audd_0x39ceba2b467fa987546000eb5d1373acf1f3a2e1",
+    contractAddress: "0x39ceba2b467fa987546000eb5d1373acf1f3a2e1",
+    parentCurrency: getMockedCurrency(),
+    tokenType: "erc20",
+    name: "AUDD",
+    ticker: "AUDD",
+    delisted: false,
+    disableCountervalue: false,
+    units: [
+      {
+        name: "AUDD",
+        code: "AUDD",
+        magnitude: 6,
       },
     ],
   },
@@ -85,19 +103,53 @@ export const getTokenCurrencyFromCAL = (
   };
 };
 
-export const getMockedTokenCurrency = (overrides?: Partial<TokenCurrency>): TokenCurrency => {
+export const getTokenCurrencyFromCALByType = (
+  type: "hts" | "erc20",
+  overrides?: Partial<TokenCurrency>,
+): TokenCurrency => {
+  const token = HARDCODED_HEDERA_TOKENS.find(t => t.tokenType === type);
+
+  invariant(token, `token of type ${type} not found in CAL`);
+
   return {
-    id: "hedera/hts/test_0.0.1234567",
+    ...token,
+    ...overrides,
+  };
+};
+
+export const getMockedHTSTokenCurrency = (overrides?: Partial<TokenCurrency>): TokenCurrency => {
+  return {
+    id: "hedera/hts/test1_0.0.1234567",
     contractAddress: "0.0.1001",
     parentCurrency: getMockedCurrency(),
     tokenType: "hts",
-    name: "Test token",
-    ticker: "TEST",
+    name: "Test HTS token",
+    ticker: "TEST1",
+    type: "TokenCurrency",
+    units: [
+      {
+        name: "Test HTS",
+        code: "TEST1",
+        magnitude: 8,
+      },
+    ],
+    ...overrides,
+  };
+};
+
+export const getMockedERC20TokenCurrency = (overrides?: Partial<TokenCurrency>): TokenCurrency => {
+  return {
+    id: "hedera/erc20/_0x915fe7c00730c08708581e30e27d9c0605be40bd",
+    contractAddress: "0x915fe7c00730c08708581e30e27d9c0605be40bd",
+    parentCurrency: getMockedCurrency(),
+    tokenType: "erc20",
+    name: "Test ERC20 token",
+    ticker: "TEST2",
     type: "TokenCurrency",
     units: [
       {
-        name: "Test",
-        code: "TEST",
+        name: "Test ERC20",
+        code: "TEST2",
         magnitude: 8,
       },
     ],

package/src/test/fixtures/mirror.fixture.ts

@@ -1,4 +1,8 @@
-import { HederaMirrorToken } from "../../types";
+import type {
+  HederaMirrorCoinTransfer,
+  HederaMirrorToken,
+  HederaMirrorTokenTransfer,
+} from "../../types";
 
 export const getMockedMirrorToken = (overrides?: Partial<HederaMirrorToken>): HederaMirrorToken => {
   return {
@@ -12,3 +16,21 @@ export const getMockedMirrorToken = (overrides?: Partial<HederaMirrorToken>): He
     ...overrides,
   };
 };
+
+export const createMirrorCoinTransfer = (
+  account: string,
+  amount: number,
+): HederaMirrorCoinTransfer => ({
+  account,
+  amount,
+});
+
+export const createMirrorTokenTransfer = (
+  account: string,
+  amount: number,
+  tokenId: string,
+): HederaMirrorTokenTransfer => ({
+  token_id: tokenId,
+  account,
+  amount,
+});

package/src/test/fixtures/thirdweb.fixture.ts

@@ -0,0 +1,33 @@
+import { ERC20_TRANSFER_EVENT_TOPIC } from "../../constants";
+import type { HederaThirdwebTransaction } from "../../types";
+
+export const getMockedThirdwebTransaction = (
+  overrides?: Partial<HederaThirdwebTransaction>,
+): HederaThirdwebTransaction => {
+  return {
+    address: "0x0000000000000000000000000000000000000002",
+    blockHash: "0x0000000000000000000000000000000000000002",
+    blockNumber: 1,
+    blockTimestamp: 1234123,
+    chainId: "295",
+    data: "0x0000000000000000000000000000000000000002",
+    decoded: {
+      name: "test",
+      params: {
+        from: "0x0000000000000000000000000000000000000001",
+        to: "0x0000000000000000000000000000000000000002",
+        value: "10000",
+      },
+      signature: "abc",
+    },
+    logIndex: 1,
+    topics: [
+      ERC20_TRANSFER_EVENT_TOPIC,
+      "0x0000000000000000000000000000000000000001",
+      "0x0000000000000000000000000000000000000002",
+    ],
+    transactionHash: "0x0000000000000000000000000000000000000003",
+    transactionIndex: 2,
+    ...overrides,
+  };
+};

package/src/transaction.ts

@@ -44,6 +44,7 @@ export function fromTransactionRaw(tr: TransactionRaw): Transaction {
     ...commonGeneric,
     ...commonHedera,
     mode: tr.mode,
+    ...(tr.gasLimit && { gasLimit: new BigNumber(tr.gasLimit) }),
   };
 }
 
@@ -70,6 +71,7 @@ export function toTransactionRaw(t: Transaction): TransactionRaw {
     ...commonGeneric,
     ...commonHedera,
     mode: t.mode,
+    ...(t.gasLimit && { gasLimit: t.gasLimit.toString() }),
   };
 }
 

package/src/types/alpaca.ts

@@ -1,3 +1,10 @@
-import type { StringMemo } from "@ledgerhq/coin-framework/api/types";
+import type { StringMemo, TxDataNotSupported } from "@ledgerhq/coin-framework/api/types";
 
 export type HederaMemo = StringMemo;
+
+export type HederaTxData =
+  | TxDataNotSupported
+  | {
+      type: "erc20";
+      gasLimit: bigint;
+    };

package/src/types/bridge.ts

@@ -26,6 +26,7 @@ export type Transaction = TransactionCommon & {
 } & (
     | {
         mode: HEDERA_TRANSACTION_MODES.Send;
+        gasLimit?: BigNumber;
         properties?: never;
       }
     | {
@@ -45,6 +46,7 @@ export type TransactionRaw = TransactionCommonRaw & {
 } & (
     | {
         mode: HEDERA_TRANSACTION_MODES.Send;
+        gasLimit?: string;
         properties?: never;
       }
     | {
@@ -59,7 +61,7 @@ export type TransactionRaw = TransactionCommonRaw & {
 
 export type TransactionTokenAssociate = Extract<
   Transaction,
-  { mode: typeof HEDERA_TRANSACTION_MODES.TokenAssociate }
+  { mode: HEDERA_TRANSACTION_MODES.TokenAssociate }
 >;
 
 export type TransactionStatus = TransactionStatusCommon;
@@ -89,6 +91,9 @@ export type HederaOperationExtra = {
   transactionId?: string;
   associatedTokenId?: string;
   pagingToken?: string;
+  gasConsumed?: number;
+  gasLimit?: number;
+  gasUsed?: number;
   memo?: string | null;
 };
 

package/src/types/index.ts

@@ -1,4 +1,6 @@
 export * from "./alpaca";
 export * from "./bridge";
+export * from "./logic";
 export * from "./mirror";
 export * from "./signer";
+export * from "./thirdweb";

package/src/types/logic.ts

@@ -0,0 +1,44 @@
+import type BigNumber from "bignumber.js";
+import type { TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { OperationType } from "@ledgerhq/types-live";
+import type { HederaOperationExtra } from "./bridge";
+import type { HEDERA_OPERATION_TYPES } from "../constants";
+import type { HederaMirrorContractCallResult, HederaMirrorTransaction } from "./mirror";
+import type { HederaThirdwebTransaction } from "./thirdweb";
+
+export type EstimateFeesParams =
+  | {
+      currency: CryptoCurrency;
+      operationType: Exclude<HEDERA_OPERATION_TYPES, HEDERA_OPERATION_TYPES.ContractCall>;
+    }
+  | {
+      operationType: typeof HEDERA_OPERATION_TYPES.ContractCall;
+      txIntent: TransactionIntent;
+    };
+
+export interface EstimateFeesResult {
+  tinybars: BigNumber;
+  gas?: BigNumber;
+}
+
+export interface OperationERC20 {
+  thirdwebTransaction: HederaThirdwebTransaction;
+  mirrorTransaction: HederaMirrorTransaction;
+  contractCallResult: HederaMirrorContractCallResult;
+  token: TokenCurrency;
+}
+
+export interface ERC20OperationFields {
+  date: Date;
+  type: OperationType;
+  fee: BigNumber;
+  value: BigNumber;
+  senders: string[];
+  recipients: string[];
+  blockHeight: number;
+  blockHash: string;
+  extra: HederaOperationExtra;
+  standard: "erc20";
+  hasFailed: false;
+}

package/src/types/mirror.ts

@@ -1,3 +1,6 @@
+import BigNumber from "bignumber.js";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
 type FreezeStatus = "NOT_APPLICABLE" | "FROZEN" | "UNFROZEN";
 
 type KycStatus = "NOT_APPLICABLE" | "GRANTED" | "REVOKED";
@@ -19,7 +22,9 @@ export interface HederaMirrorTransaction {
   token_transfers: HederaMirrorTokenTransfer[];
   charged_tx_fee: number;
   transaction_hash: string;
+  transaction_id: string;
   consensus_timestamp: string;
+  entity_id: string | null;
   result: string;
   name: string;
   memo_base64?: string;
@@ -68,3 +73,33 @@ export interface HederaMirrorTransactionsResponse {
     next: string | null;
   };
 }
+
+export interface HederaMirrorNetworkFees {
+  fees: {
+    gas: number;
+    transaction_type: "ContractCall" | "ContractCreate" | "EthereumTransaction";
+  }[];
+  timestamp: string;
+}
+
+export interface HederaMirrorContractCallResult {
+  contract_id: string;
+  block_gas_used: number;
+  gas_consumed: number;
+  gas_limit: number;
+  gas_used: number;
+  timestamp: string;
+}
+
+export interface HederaERC20TokenBalance {
+  token: TokenCurrency;
+  balance: BigNumber;
+}
+
+export interface HederaMirrorContractCallEstimate {
+  result: string;
+}
+
+export interface HederaMirrorContractCallBalance {
+  result: string;
+}

package/src/types/thirdweb.ts

@@ -0,0 +1,36 @@
+export interface HederaThirdwebDecodedTransferParams {
+  from: string;
+  to: string;
+  value: string;
+}
+
+export interface HederaThirdwebTransaction {
+  address: string;
+  blockHash: string;
+  blockNumber: number;
+  blockTimestamp: number;
+  chainId: string;
+  data: string;
+  decoded: {
+    name: string;
+    params: Record<string, unknown>;
+    signature: string;
+  };
+  logIndex: number;
+  topics: string[];
+  transactionHash: string;
+  transactionIndex: number;
+}
+
+export interface HederaThirdwebPagination {
+  limit: number;
+  page: number;
+  totalCount: number;
+}
+
+export interface HederaThirdwebContractEventsResponse {
+  result: {
+    events: HederaThirdwebTransaction[];
+    pagination: HederaThirdwebPagination;
+  };
+}