@ledgerhq/coin-hedera 1.13.0-nightly.2 → 1.13.0-nightly.20251031023756

package/src/bridge/utils.ts

@@ -1,16 +1,5 @@
 import BigNumber from "bignumber.js";
-import murmurhash from "imurmurhash";
-import invariant from "invariant";
-import { AccountId } from "@hashgraph/sdk";
-import { InvalidAddress } from "@ledgerhq/errors";
 import type { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
-import cvsApi from "@ledgerhq/live-countervalues/api/index";
-import {
-  findCryptoCurrencyById,
-  findTokenByAddressInCurrency,
-  getFiatCurrencyByTicker,
-  listTokensForCryptoCurrency,
-} from "@ledgerhq/cryptoassets";
 import {
   decodeTokenAccountId,
   emptyHistoryCache,
@@ -19,63 +8,14 @@ import {
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import type { CryptoCurrency, Currency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
+import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { HEDERA_OPERATION_TYPES } from "../constants";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
-import type { HederaOperationExtra, Transaction } from "../types";
-import { getAccount } from "../api/mirror";
-import { getHederaClient } from "../api/network";
-import type { HederaMirrorToken } from "../api/types";
-import { HederaRecipientInvalidChecksum } from "../errors";
-import { isTokenAssociateTransaction, isValidExtra } from "../logic";
-import { BASE_USD_FEE_BY_OPERATION_TYPE, HEDERA_OPERATION_TYPES } from "../constants";
-
-const ESTIMATED_FEE_SAFETY_RATE = 2;
-
-// note: this is currently called frequently by getTransactionStatus; LRU cache prevents duplicated requests
-export const getCurrencyToUSDRate = makeLRUCache(
-  async (currency: Currency) => {
-    try {
-      const [rate] = await cvsApi.fetchLatest([
-        {
-          from: currency,
-          to: getFiatCurrencyByTicker("USD"),
-          startDate: new Date(),
-        },
-      ]);
-
-      invariant(rate, "no value returned from cvs api");
-
-      return new BigNumber(rate);
-    } catch {
-      return null;
-    }
-  },
-  currency => currency.ticker,
-  seconds(3),
-);
-
-export const getEstimatedFees = async (
-  account: Account,
-  operationType: HEDERA_OPERATION_TYPES,
-): Promise<BigNumber> => {
-  try {
-    const usdRate = await getCurrencyToUSDRate(account.currency);
-
-    if (usdRate) {
-      return new BigNumber(BASE_USD_FEE_BY_OPERATION_TYPE[operationType])
-        .dividedBy(new BigNumber(usdRate))
-        .integerValue(BigNumber.ROUND_CEIL)
-        .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
-    }
-    // eslint-disable-next-line no-empty
-  } catch {}
-
-  // as fees are based on a currency conversion, we stay
-  // on the safe side here and double the estimate for "max spendable"
-  return new BigNumber("150200").multipliedBy(ESTIMATED_FEE_SAFETY_RATE); // 0.001502 ℏ (as of 2023-03-14)
-};
+import { estimateFees } from "../logic/estimateFees";
+import { isTokenAssociateTransaction, isValidExtra } from "../logic/utils";
+import type { HederaOperationExtra, Transaction, HederaMirrorToken } from "../types";
 
 interface CalculateAmountResult {
   amount: BigNumber;
@@ -91,7 +31,7 @@ const calculateCoinAmount = async ({
   transaction: Transaction;
   operationType: HEDERA_OPERATION_TYPES;
 }): Promise<CalculateAmountResult> => {
-  const estimatedFees = await getEstimatedFees(account, operationType);
+  const estimatedFees = await estimateFees(account.currency, operationType);
   const amount = transaction.useAllAmount
     ? await estimateMaxSpendable({ account, transaction })
     : transaction.amount;
@@ -142,62 +82,30 @@ export const calculateAmount = ({
   return calculateCoinAmount({ account, transaction, operationType });
 };
 
-// NOTE: convert from the non-url-safe version of base64 to the url-safe version (that the explorer uses)
-export function base64ToUrlSafeBase64(data: string): string {
-  // Might be nice to use this alternative if .nvmrc changes to >= Node v14.18.0
-  // base64url encoding option isn't supported until then
-  // Buffer.from(data, "base64").toString("base64url");
-
-  return data.replace(/\//g, "_").replace(/\+/g, "-");
-}
-
-const simpleSyncHashMemoize: Record<string, string> = {};
-
-export const getSyncHash = (
-  currency: CryptoCurrency,
-  blacklistedTokenIds: string[] = [],
-): string => {
-  const tokens = listTokensForCryptoCurrency(currency);
-
-  const stringToHash =
-    currency.id +
-    tokens.map(token => token.id + token.contractAddress + token.name + token.ticker).join("") +
-    blacklistedTokenIds.join("");
-
-  if (!simpleSyncHashMemoize[stringToHash]) {
-    simpleSyncHashMemoize[stringToHash] = `0x${murmurhash(stringToHash).result().toString(16)}`;
-  }
-
-  return simpleSyncHashMemoize[stringToHash];
-};
-
 export const getSubAccounts = async (
   accountId: string,
   lastTokenOperations: Operation[],
   mirrorTokens: HederaMirrorToken[],
 ): Promise<TokenAccount[]> => {
   // Creating a Map of Operations by TokenCurrencies in order to know which TokenAccounts should be synced as well
-  const operationsByToken = lastTokenOperations.reduce<Map<TokenCurrency, Operation[]>>(
-    (acc, tokenOperation) => {
-      const { token } = decodeTokenAccountId(tokenOperation.accountId);
-      if (!token) return acc;
-
-      const isTokenListedInCAL = findTokenByAddressInCurrency(
-        token.contractAddress,
-        token.parentCurrency.id,
-      );
-      if (!isTokenListedInCAL) return acc;
-
-      if (!acc.has(token)) {
-        acc.set(token, []);
-      }
+  const operationsByToken = new Map<TokenCurrency, Operation[]>();
 
-      acc.get(token)?.push(tokenOperation);
+  for (const tokenOperation of lastTokenOperations) {
+    const { token } = await decodeTokenAccountId(tokenOperation.accountId);
+    if (!token) continue;
+
+    const isTokenListedInCAL = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      token.contractAddress,
+      token.parentCurrency.id,
+    );
+    if (!isTokenListedInCAL) continue;
 
-      return acc;
-    },
-    new Map<TokenCurrency, Operation[]>(),
-  );
+    if (!operationsByToken.has(token)) {
+      operationsByToken.set(token, []);
+    }
+
+    operationsByToken.get(token)?.push(tokenOperation);
+  }
 
   const subAccounts: TokenAccount[] = [];
 
@@ -234,7 +142,10 @@ export const getSubAccounts = async (
     const parentAccountId = accountId;
     const rawBalance = rawToken.balance;
     const balance = new BigNumber(rawBalance);
-    const token = findTokenByAddressInCurrency(rawToken.token_id, "hedera");
+    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      rawToken.token_id,
+      "hedera",
+    );
 
     if (!token) {
       continue;
@@ -265,14 +176,15 @@ export const getSubAccounts = async (
   return subAccounts;
 };
 
-type CoinOperationForOrphanChildOperation = Operation & Required<Pick<Operation, "subOperations">>;
+type CoinOperationForOrphanChildOperation = Operation<HederaOperationExtra> &
+  Required<Pick<Operation, "subOperations">>;
 
 // create NONE coin operation that will be a parent of an orphan child operation
-const makeCoinOperationForOrphanChildOperation = (
-  childOperation: Operation,
-): CoinOperationForOrphanChildOperation => {
+const makeCoinOperationForOrphanChildOperation = async (
+  childOperation: Operation<HederaOperationExtra>,
+): Promise<CoinOperationForOrphanChildOperation> => {
   const type = "NONE";
-  const { accountId } = decodeTokenAccountId(childOperation.accountId);
+  const { accountId } = await decodeTokenAccountId(childOperation.accountId);
   const id = encodeOperationId(accountId, childOperation.hash, type);
 
   return {
@@ -298,34 +210,16 @@ const makeCoinOperationForOrphanChildOperation = (
 // this util handles:
 // - linking sub operations with coin operations, e.g. token transfer with fee payment
 // - if possible, assigning `extra.associatedTokenId = mirrorToken.tokenId` based on operation's consensus timestamp
-export const prepareOperations = (
-  coinOperations: Operation[],
-  tokenOperations: Operation[],
-  mirrorTokens: HederaMirrorToken[],
-): Operation[] => {
+export const prepareOperations = async (
+  coinOperations: Operation<HederaOperationExtra>[],
+  tokenOperations: Operation<HederaOperationExtra>[],
+): Promise<Operation<HederaOperationExtra>[]> => {
   const preparedCoinOperations = coinOperations.map(op => ({ ...op }));
   const preparedTokenOperations = tokenOperations.map(op => ({ ...op }));
 
-  // loop through coin operations to:
-  // - enrich ASSOCIATE_TOKEN operations with extra.associatedTokenId
-  // - prepare a map of hash => operations
+  // loop through coin operations to prepare a map of hash => operations
   const coinOperationsByHash: Record<string, CoinOperationForOrphanChildOperation[]> = {};
   preparedCoinOperations.forEach(op => {
-    const extra = isValidExtra(op.extra) ? op.extra : null;
-
-    if (op.type === "ASSOCIATE_TOKEN" && extra?.consensusTimestamp) {
-      const relatedMirrorToken = mirrorTokens.find(t => {
-        return t.created_timestamp === extra.consensusTimestamp;
-      });
-
-      if (relatedMirrorToken) {
-        op.extra = {
-          ...extra,
-          associatedTokenId: relatedMirrorToken.token_id,
-        } satisfies HederaOperationExtra;
-      }
-    }
-
     if (!coinOperationsByHash[op.hash]) {
       coinOperationsByHash[op.hash] = [];
     }
@@ -336,13 +230,13 @@ export const prepareOperations = (
 
   // loop through token operations to potentially copy them as a child operation of a coin operation
   for (const tokenOperation of preparedTokenOperations) {
-    const { token } = decodeTokenAccountId(tokenOperation.accountId);
+    const { token } = await decodeTokenAccountId(tokenOperation.accountId);
     if (!token) continue;
 
     let mainOperations = coinOperationsByHash[tokenOperation.hash];
 
     if (!mainOperations?.length) {
-      const noneOperation = makeCoinOperationForOrphanChildOperation(tokenOperation);
+      const noneOperation = await makeCoinOperationForOrphanChildOperation(tokenOperation);
       mainOperations = [noneOperation];
       preparedCoinOperations.push(noneOperation);
     }
@@ -456,64 +350,3 @@ export function patchOperationWithExtra(
     nftOperations: (operation.nftOperations ?? []).map(op => ({ ...op, extra })),
   };
 }
-
-export const checkAccountTokenAssociationStatus = makeLRUCache(
-  async (address: string, tokenId: string) => {
-    const [parsingError, parsingResult] = safeParseAccountId(address);
-
-    if (parsingError) {
-      throw parsingError;
-    }
-
-    const addressWithoutChecksum = parsingResult.accountId;
-    const mirrorAccount = await getAccount(addressWithoutChecksum);
-
-    // auto association is enabled
-    if (mirrorAccount.max_automatic_token_associations === -1) {
-      return true;
-    }
-
-    const isTokenAssociated = mirrorAccount.balance.tokens.some(token => {
-      return token.token_id === tokenId;
-    });
-
-    return isTokenAssociated;
-  },
-  (accountId, tokenId) => `${accountId}-${tokenId}`,
-  seconds(30),
-);
-
-export const safeParseAccountId = (
-  address: string,
-): [Error, null] | [null, { accountId: string; checksum: string | null }] => {
-  const currency = findCryptoCurrencyById("hedera");
-  const currencyName = currency?.name ?? "Hedera";
-
-  try {
-    const accountId = AccountId.fromString(address);
-
-    // verify checksum if present
-    // FIXME: migrate to EntityIdHelper methods once SDK is upgraded:
-    // https://github.com/hiero-ledger/hiero-sdk-js/blob/main/src/EntityIdHelper.js#L197
-    // https://github.com/hiero-ledger/hiero-sdk-js/blob/main/src/EntityIdHelper.js#L446
-    const checksum: string | null = address.split("-")[1] ?? null;
-    if (checksum) {
-      const client = getHederaClient();
-      const recipientWithChecksum = accountId.toStringWithChecksum(client);
-      const expectedChecksum = recipientWithChecksum.split("-")[1];
-
-      if (checksum !== expectedChecksum) {
-        return [new HederaRecipientInvalidChecksum(), null];
-      }
-    }
-
-    const result = {
-      accountId: accountId.toString(),
-      checksum,
-    };
-
-    return [null, result];
-  } catch (err) {
-    return [new InvalidAddress("", { currencyName }), null];
-  }
-};

package/src/config.ts

@@ -0,0 +1,7 @@
+import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type HederaCoinConfig = CurrencyConfig;
+
+const coinConfig = buildCoinConfig<HederaCoinConfig>();
+
+export default coinConfig;

package/src/constants.ts

@@ -1,12 +1,11 @@
 /**
- * Internal types used to distinguish custom Hedera transaction behaviors.
- * These can be stored in transaction.properties.name and used to route specific preparation logic.
+ * Internal types to distinguish custom Hedera transaction behaviors.
+ * These can be used in transaction.mode and used to route specific preparation logic.
  */
-export const HEDERA_TRANSACTION_KINDS = {
-  TokenAssociate: {
-    name: "tokenAssociate",
-  },
-} as const satisfies Record<string, Record<string, unknown> & { name: string }>;
+export enum HEDERA_TRANSACTION_MODES {
+  Send = "send",
+  TokenAssociate = "token-associate",
+}
 
 /**
  * Enum representing the supported Hedera operation types for fee estimation
@@ -17,7 +16,14 @@ export enum HEDERA_OPERATION_TYPES {
   TokenAssociate = "TokenAssociate",
 }
 
-const TINYBAR_SCALE = 8;
+export const TINYBAR_SCALE = 8;
+
+export const ESTIMATED_FEE_SAFETY_RATE = 2;
+
+// old value moved from https://github.com/LedgerHQ/ledger-live/blob/8447b68b7c6f1e7ccd4aa9db4da0e6c8de36a88e/libs/coin-modules/coin-hedera/src/bridge/utils.ts#L77
+export const DEFAULT_TINYBAR_FEE = 150200;
+
+export const SYNTHETIC_BLOCK_WINDOW_SECONDS = 10;
 
 /**
  * https://docs.hedera.com/hedera/networks/mainnet/fees
@@ -25,7 +31,7 @@ const TINYBAR_SCALE = 8;
  * These are Hedera's estimated fee costs in USD, scaled to tinybars (1 HBAR = 10^8 tinybars),
  * so they can be converted into actual HBAR amounts based on current USD/crypto rates.
  *
- * Used in fee estimation logic (getEstimatedFees function) to determine whether an account
+ * Used in fee estimation logic (estimateFees function) to determine whether an account
  * has sufficient balance to cover the cost of a transaction (e.g. token association).
  */
 export const BASE_USD_FEE_BY_OPERATION_TYPE = {

package/src/deviceTransactionConfig.ts

@@ -1,7 +1,7 @@
 import type { AccountLike, Account } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus } from "./types";
 import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
-import { isTokenAssociateTransaction } from "./logic";
+import { isTokenAssociateTransaction } from "./logic/utils";
+import type { Transaction, TransactionStatus } from "./types";
 
 async function getDeviceTransactionConfig({
   transaction,

package/src/logic/broadcast.test.ts

@@ -0,0 +1,58 @@
+import { broadcast } from "./broadcast";
+import { rpcClient } from "../network/rpc";
+import { deserializeTransaction } from "./utils";
+
+jest.mock("../network/rpc");
+jest.mock("./utils");
+
+describe("broadcast", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should deserialize and broadcast a transaction successfully", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const mockDeserializedTx = { someProperty: "mockTransaction" } as any;
+    const mockResponse = { transactionId: "mock-transaction-id" } as any;
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (rpcClient.broadcastTransaction as jest.Mock).mockResolvedValue(mockResponse);
+
+    const result = await broadcast(txWithSignature);
+
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledTimes(1);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+    expect(result).toBe(mockResponse);
+  });
+
+  it("should propagate errors from deserializeTransaction", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const error = new Error("Deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    await expect(broadcast(txWithSignature)).rejects.toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from broadcastTransaction", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const mockDeserializedTx = { someProperty: "mockTransaction" } as any;
+    const error = new Error("Network error");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (rpcClient.broadcastTransaction as jest.Mock).mockRejectedValue(error);
+
+    await expect(broadcast(txWithSignature)).rejects.toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledTimes(1);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+  });
+});

package/src/logic/broadcast.ts

@@ -0,0 +1,8 @@
+import type { TransactionResponse } from "@hashgraph/sdk";
+import { rpcClient } from "../network/rpc";
+import { deserializeTransaction } from "./utils";
+
+export const broadcast = async (txWithSignature: string): Promise<TransactionResponse> => {
+  const hederaTransaction = deserializeTransaction(txWithSignature);
+  return await rpcClient.broadcastTransaction(hederaTransaction);
+};

package/src/logic/combine.test.ts

@@ -0,0 +1,119 @@
+import { PublicKey } from "@hashgraph/sdk";
+import { combine } from "./combine";
+import { deserializeSignature, deserializeTransaction, serializeTransaction } from "./utils";
+
+jest.mock("./utils");
+jest.mock("@hashgraph/sdk");
+
+describe("combine", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should combine transaction with signature successfully", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const mockBufferSignature = Buffer.from("mock-signature");
+    const mockBufferPublicKey = { key: "mock-public-key" } as any;
+    const mockSerializedTxWithSignature = "serialized-transaction-with-signature";
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockReturnValue(mockBufferSignature);
+    (PublicKey.fromString as jest.Mock).mockReturnValue(mockBufferPublicKey);
+    (serializeTransaction as jest.Mock).mockReturnValue(mockSerializedTxWithSignature);
+
+    const result = combine(tx, signature, publicKey);
+
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).toHaveBeenCalledTimes(1);
+    expect(PublicKey.fromString).toHaveBeenCalledWith(publicKey);
+    expect(mockDeserializedTx.addSignature).toHaveBeenCalledTimes(1);
+    expect(mockDeserializedTx.addSignature).toHaveBeenCalledWith(
+      mockBufferPublicKey,
+      mockBufferSignature,
+    );
+    expect(serializeTransaction).toHaveBeenCalledTimes(1);
+    expect(serializeTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+    expect(result).toBe(mockSerializedTxWithSignature);
+  });
+
+  it("should throw an error when public key is not provided", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+
+    expect(() => combine(tx, signature, undefined)).toThrow();
+    expect(deserializeTransaction).not.toHaveBeenCalled();
+    expect(deserializeSignature).not.toHaveBeenCalled();
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from deserializeTransaction", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+    const error = new Error("Deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).not.toHaveBeenCalled();
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from deserializeSignature", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const error = new Error("Signature deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from PublicKey.fromString", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "invalid-public-key";
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const mockBufferSignature = Buffer.from("mock-signature");
+    const error = new Error("Invalid public key");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockReturnValue(mockBufferSignature);
+    (PublicKey.fromString as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).toHaveBeenCalledTimes(1);
+    expect(PublicKey.fromString).toHaveBeenCalledWith(publicKey);
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+});

package/src/logic/combine.ts

@@ -0,0 +1,14 @@
+import invariant from "invariant";
+import { PublicKey } from "@hashgraph/sdk";
+import { deserializeSignature, deserializeTransaction, serializeTransaction } from "./utils";
+
+export function combine(tx: string, signature: string, publicKey?: string): string {
+  invariant(publicKey, "hedera: public key is required to combine the transaction");
+
+  const hederaTransaction = deserializeTransaction(tx);
+  const bufferSignature = deserializeSignature(signature);
+  const bufferPublicKey = PublicKey.fromString(publicKey);
+  hederaTransaction.addSignature(bufferPublicKey, bufferSignature);
+
+  return serializeTransaction(hederaTransaction);
+}