@ledgerhq/coin-hedera 1.10.1 → 1.10.2-nightly.0

package/src/api/mirror.test.ts

@@ -1,5 +1,5 @@
 import network from "@ledgerhq/live-network/network";
-import { getAccountTransactions } from "./mirror";
+import { getAccount, getAccountTokens, getAccountTransactions } from "./mirror";
 
 jest.mock("@ledgerhq/live-network/network");
 const mockedNetwork = jest.mocked(network);
@@ -26,10 +26,10 @@ describe("getAccountTransactions", () => {
 
     await getAccountTransactions("0.0.1234", null);
 
-    const calledUrl = mockedNetwork.mock.calls[0][0].url;
-    expect(calledUrl).toContain("account.id=0.0.1234");
-    expect(calledUrl).toContain("limit=100");
-    expect(calledUrl).toContain("order=desc");
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+    expect(requestUrl).toContain("account.id=0.0.1234");
+    expect(requestUrl).toContain("limit=100");
+    expect(requestUrl).toContain("order=desc");
   });
 
   test("should keep fetching if links.next is present", async () => {
@@ -72,3 +72,77 @@ describe("getAccountTransactions", () => {
     expect(mockedNetwork).toHaveBeenCalledTimes(5);
   });
 });
+
+describe("getAccount", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return account data", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      makeMockResponse({
+        account: "0.0.1234",
+        max_automatic_token_associations: 0,
+        balance: {
+          balance: 1000,
+          timestamp: "1749047764.000113442",
+          tokens: [],
+        },
+      }),
+    );
+
+    const result = await getAccount("0.0.1234");
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result.account).toEqual("0.0.1234");
+    expect(requestUrl).toContain("/api/v1/accounts/0.0.1234");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("getAccountTokens", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return all tokens if only one page is needed", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      makeMockResponse({
+        tokens: [
+          { token_id: "0.0.1001", balance: 10 },
+          { token_id: "0.0.1002", balance: 20 },
+        ],
+        links: { next: null },
+      }),
+    );
+
+    const result = await getAccountTokens("0.0.1234");
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result.map(t => t.token_id)).toEqual(["0.0.1001", "0.0.1002"]);
+    expect(requestUrl).toContain("/api/v1/accounts/0.0.1234/tokens");
+    expect(requestUrl).toContain("limit=100");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should keep fetching if links.next is present and new tokens are returned", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        makeMockResponse({
+          tokens: [{ token_id: "0.0.1001", balance: 10 }],
+          links: { next: "/next-1" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        makeMockResponse({
+          tokens: [{ token_id: "0.0.1002", balance: 20 }],
+          links: { next: null },
+        }),
+      );
+
+    const result = await getAccountTokens("0.0.1234");
+
+    expect(result.map(t => t.token_id)).toEqual(["0.0.1001", "0.0.1002"]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(2);
+  });
+});

package/src/api/mirror.ts

@@ -1,12 +1,8 @@
-import { AccountId } from "@hashgraph/sdk";
 import network from "@ledgerhq/live-network/network";
-import { Operation, OperationType } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
 import { getEnv } from "@ledgerhq/live-env";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { getAccountBalance } from "./network";
-import { base64ToUrlSafeBase64 } from "../bridge/utils";
-import { HederaOperationExtra } from "../types";
+import type { HederaMirrorAccount, HederaMirrorToken, HederaMirrorTransaction } from "./types";
+import { HederaAddAccountError } from "../errors";
+import { LedgerAPI4xx } from "@ledgerhq/errors";
 
 const getMirrorApiUrl = (): string => getEnv("API_HEDERA_MIRROR");
 
@@ -17,45 +13,33 @@ const fetch = (path: string) => {
   });
 };
 
-interface HederaMirrorAccount {
-  accountId: AccountId;
-  balance: BigNumber;
-}
-
 export async function getAccountsForPublicKey(publicKey: string): Promise<HederaMirrorAccount[]> {
   let r;
   try {
-    r = await fetch(`/api/v1/accounts?account.publicKey=${publicKey}&balance=false`);
+    r = await fetch(`/api/v1/accounts?account.publicKey=${publicKey}&balance=true&limit=100`);
   } catch (e: any) {
     if (e.name === "LedgerAPI4xx") return [];
     throw e;
   }
-  const rawAccounts = r.data.accounts;
-  const accounts: HederaMirrorAccount[] = [];
 
-  for (const raw of rawAccounts) {
-    const accountBalance = await getAccountBalance(raw.account);
-
-    accounts.push({
-      accountId: AccountId.fromString(raw.account),
-      balance: accountBalance.balance,
-    });
-  }
+  const accounts = r.data.accounts as HederaMirrorAccount[];
 
   return accounts;
 }
 
-interface HederaMirrorTransfer {
-  account: string;
-  amount: number;
-}
+export async function getAccount(address: string): Promise<HederaMirrorAccount> {
+  try {
+    const res = await fetch(`/api/v1/accounts/${address}`);
+    const account = res.data as HederaMirrorAccount;
+
+    return account;
+  } catch (error) {
+    if (error instanceof LedgerAPI4xx && "status" in error && error.status === 404) {
+      throw new HederaAddAccountError();
+    }
 
-interface HederaMirrorTransaction {
-  transfers: HederaMirrorTransfer[];
-  charged_tx_fee: string;
-  transaction_hash: string;
-  consensus_timestamp: string;
-  transaction_id: string;
+    throw error;
+  }
 }
 
 export async function getAccountTransactions(
@@ -88,85 +72,20 @@ export async function getAccountTransactions(
   return transactions;
 }
 
-export async function getOperationsForAccount(
-  ledgerAccountId: string,
-  address: string,
-  latestOperationTimestamp: string | null,
-): Promise<Operation[]> {
-  const rawOperations = await getAccountTransactions(address, latestOperationTimestamp);
-  const operations: Operation[] = [];
-
-  for (const raw of rawOperations) {
-    const { consensus_timestamp, transaction_id } = 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);
-        }
-      }
-    }
+export async function getAccountTokens(address: string): Promise<HederaMirrorToken[]> {
+  const tokens: HederaMirrorToken[] = [];
+  const params = new URLSearchParams({
+    limit: "100",
+  });
 
-    // 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: {
-        consensusTimestamp: consensus_timestamp,
-        transactionId: transaction_id,
-      } satisfies HederaOperationExtra,
-      fee,
-      hash,
-      recipients,
-      senders,
-      accountId: ledgerAccountId,
-      id: encodeOperationId(ledgerAccountId, hash, type),
-      type,
-    });
+  let nextUrl = `/api/v1/accounts/${address}/tokens?${params.toString()}`;
+
+  while (nextUrl) {
+    const res = await fetch(nextUrl);
+    const newTokens = res.data.tokens as HederaMirrorToken[];
+    tokens.push(...newTokens);
+    nextUrl = res.data.links.next;
   }
 
-  return operations;
+  return tokens;
 }

package/src/api/network.ts

@@ -1,4 +1,5 @@
 import BigNumber from "bignumber.js";
+import invariant from "invariant";
 import type { Transaction as HederaTransaction, TransactionResponse } from "@hashgraph/sdk";
 import {
   Client,
@@ -8,27 +9,33 @@ import {
   TransactionId,
   AccountBalanceQuery,
   HbarUnit,
+  TokenAssociateTransaction,
 } from "@hashgraph/sdk";
-import { Account } from "@ledgerhq/types-live";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
 import { HederaAddAccountError } from "../errors";
 import { Transaction } from "../types";
+import { isTokenAssociateTransaction } from "../logic";
 
 export function broadcastTransaction(transaction: HederaTransaction): Promise<TransactionResponse> {
   return transaction.execute(getClient());
 }
 
-export async function buildUnsignedTransaction({
+// https://github.com/LedgerHQ/ledger-live/pull/72/commits/1e942687d4301660e43e0c4b5419fcfa2733b290
+const nodeAccountIds: AccountId[] = [new AccountId(3)];
+
+async function buildUnsignedCoinTransaction({
   account,
   transaction,
 }: {
   account: Account;
   transaction: Transaction;
 }): Promise<TransferTransaction> {
-  const hbarAmount = Hbar.fromTinybars(transaction.amount);
   const accountId = account.freshAddress;
+  const hbarAmount = Hbar.fromTinybars(transaction.amount);
 
   return new TransferTransaction()
-    .setNodeAccountIds([new AccountId(3)])
+    .setNodeAccountIds(nodeAccountIds)
     .setTransactionId(TransactionId.generate(accountId))
     .setTransactionMemo(transaction.memo ?? "")
     .addHbarTransfer(accountId, hbarAmount.negated())
@@ -36,6 +43,66 @@ export async function buildUnsignedTransaction({
     .freeze();
 }
 
+async function buildUnsignedTokenTransaction({
+  account,
+  tokenAccount,
+  transaction,
+}: {
+  account: Account;
+  tokenAccount: TokenAccount;
+  transaction: Transaction;
+}): Promise<TransferTransaction> {
+  const accountId = account.freshAddress;
+  const tokenId = tokenAccount.token.contractAddress;
+
+  return new TransferTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
+    .addTokenTransfer(tokenId, accountId, transaction.amount.negated().toNumber())
+    .addTokenTransfer(tokenId, transaction.recipient, transaction.amount.toNumber())
+    .freeze();
+}
+
+async function buildTokenAssociateTransaction({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<TokenAssociateTransaction> {
+  invariant(isTokenAssociateTransaction(transaction), "invalid transaction properties");
+
+  const accountId = account.freshAddress;
+
+  return new TokenAssociateTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
+    .setAccountId(accountId)
+    .setTokenIds([transaction.properties.token.contractAddress])
+    .freeze();
+}
+
+export async function buildUnsignedTransaction({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<TransferTransaction | TokenAssociateTransaction> {
+  const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
+  const isTokenTransaction = isTokenAccount(subAccount);
+
+  if (isTokenAssociateTransaction(transaction)) {
+    return buildTokenAssociateTransaction({ account, transaction });
+  } else if (isTokenTransaction) {
+    return buildUnsignedTokenTransaction({ account, tokenAccount: subAccount, transaction });
+  } else {
+    return buildUnsignedCoinTransaction({ account, transaction });
+  }
+}
+
 export interface AccountBalance {
   balance: BigNumber;
 }

package/src/api/types.ts

@@ -0,0 +1,48 @@
+type FreezeStatus = "NOT_APPLICABLE" | "FROZEN" | "UNFROZEN";
+
+type KycStatus = "NOT_APPLICABLE" | "GRANTED" | "REVOKED";
+
+export interface HederaMirrorCoinTransfer {
+  account: string;
+  amount: number;
+}
+
+export interface HederaMirrorTokenTransfer {
+  token_id: string;
+  account: string;
+  amount: number;
+  is_approval?: boolean;
+}
+
+export interface HederaMirrorTransaction {
+  transfers: HederaMirrorCoinTransfer[];
+  token_transfers: HederaMirrorTokenTransfer[];
+  charged_tx_fee: string;
+  transaction_hash: string;
+  consensus_timestamp: string;
+  result: string;
+  name: string;
+}
+
+export interface HederaMirrorToken {
+  automatic_association: boolean;
+  balance: number;
+  created_timestamp: string;
+  decimals: number;
+  token_id: string;
+  freeze_status: FreezeStatus;
+  kyc_status: KycStatus;
+}
+
+export interface HederaMirrorAccount {
+  account: string;
+  max_automatic_token_associations: number;
+  balance: {
+    balance: number;
+    timestamp: string;
+    tokens: {
+      token_id: string;
+      balance: number;
+    }[];
+  };
+}

package/src/api/utils.ts

@@ -0,0 +1,150 @@
+import BigNumber from "bignumber.js";
+import { AccountId } from "@hashgraph/sdk";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import type { HederaMirrorTokenTransfer, HederaMirrorCoinTransfer } from "./types";
+import { getAccountTransactions } from "./mirror";
+import { base64ToUrlSafeBase64 } from "../bridge/utils";
+
+function isValidRecipient(accountId: AccountId, recipients: string[]): boolean {
+  if (accountId.shard.eq(0) && accountId.realm.eq(0)) {
+    // account is a node, only add to list if we have none
+    if (accountId.num.lt(100)) {
+      return recipients.length === 0;
+    }
+
+    // account is a system account that is not a node, do NOT add
+    if (accountId.num.lt(1000)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function parseTransfers(
+  mirrorTransfers: (HederaMirrorCoinTransfer | HederaMirrorTokenTransfer)[],
+  address: string,
+): Pick<Operation, "type" | "value" | "senders" | "recipients"> {
+  let value = new BigNumber(0);
+  let type: OperationType = "NONE";
+
+  const senders: string[] = [];
+  const recipients: string[] = [];
+
+  for (const transfer of mirrorTransfers) {
+    const amount = new BigNumber(transfer.amount);
+    const accountId = AccountId.fromString(transfer.account);
+
+    if (transfer.account === address) {
+      value = amount.abs();
+      type = amount.isNegative() ? "OUT" : "IN";
+    }
+
+    if (amount.isNegative()) {
+      senders.push(transfer.account);
+    } else if (isValidRecipient(accountId, recipients)) {
+      recipients.push(transfer.account);
+    }
+  }
+
+  // NOTE: earlier addresses are the "fee" addresses
+  senders.reverse();
+  recipients.reverse();
+
+  return {
+    type,
+    value,
+    senders,
+    recipients,
+  };
+}
+
+export async function getOperationsForAccount(
+  ledgerAccountId: string,
+  address: string,
+  latestOperationTimestamp: string | null,
+): Promise<{
+  coinOperations: Operation[];
+  tokenOperations: Operation[];
+}> {
+  const mirrorTransactions = await getAccountTransactions(address, latestOperationTimestamp);
+  const coinOperations: Operation[] = [];
+  const tokenOperations: Operation[] = [];
+
+  for (const rawTx of mirrorTransactions) {
+    const timestamp = new Date(parseInt(rawTx.consensus_timestamp.split(".")[0], 10) * 1000);
+    const hash = base64ToUrlSafeBase64(rawTx.transaction_hash);
+    const fee = new BigNumber(rawTx.charged_tx_fee);
+    const tokenTransfers = rawTx.token_transfers ?? [];
+    const transfers = rawTx.transfers ?? [];
+    const hasFailed = rawTx.result !== "SUCCESS";
+
+    if (tokenTransfers.length > 0) {
+      const tokenId = rawTx.token_transfers[0].token_id;
+      const token = findTokenByAddressInCurrency(tokenId, "hedera");
+      if (!token) continue;
+
+      const encodedTokenId = encodeTokenAccountId(ledgerAccountId, token);
+      const { type, value, senders, recipients } = parseTransfers(rawTx.token_transfers, address);
+
+      // add main FEES coin operation for send token transfer
+      if (type === "OUT") {
+        coinOperations.push({
+          id: encodeOperationId(ledgerAccountId, hash, "FEES"),
+          accountId: ledgerAccountId,
+          type: "FEES",
+          value: fee,
+          recipients,
+          senders,
+          hash,
+          fee,
+          date: timestamp,
+          blockHeight: 5,
+          blockHash: null,
+          hasFailed,
+          extra: { consensusTimestamp: rawTx.consensus_timestamp },
+        });
+      }
+
+      tokenOperations.push({
+        id: encodeOperationId(encodedTokenId, hash, type),
+        accountId: encodedTokenId,
+        type,
+        value,
+        recipients,
+        senders,
+        hash,
+        fee,
+        date: timestamp,
+        blockHeight: 5,
+        blockHash: null,
+        hasFailed,
+        extra: { consensusTimestamp: rawTx.consensus_timestamp },
+      });
+    } else if (transfers.length > 0) {
+      const { type, value, senders, recipients } = parseTransfers(rawTx.transfers, address);
+      const operationType = rawTx.name === "TOKENASSOCIATE" ? "ASSOCIATE_TOKEN" : type;
+
+      coinOperations.push({
+        id: encodeOperationId(ledgerAccountId, hash, operationType),
+        accountId: ledgerAccountId,
+        type: operationType,
+        value,
+        recipients,
+        senders,
+        hash,
+        fee,
+        date: timestamp,
+        blockHeight: 5,
+        blockHash: null,
+        hasFailed,
+        extra: { consensusTimestamp: rawTx.consensus_timestamp },
+      });
+    }
+  }
+
+  return { coinOperations, tokenOperations };
+}

package/src/bridge/broadcast.ts

@@ -4,6 +4,7 @@ import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
 import { base64ToUrlSafeBase64, patchOperationWithExtra } from "./utils";
 import { HederaOperationExtra, Transaction } from "../types";
 import { broadcastTransaction } from "../api/network";
+import { isValidExtra } from "../logic";
 
 export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
   const { signature, operation } = signedOperation;
@@ -16,6 +17,7 @@ export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signe
   const base64Hash = Buffer.from(response.transactionHash).toString("base64");
   const base64HashUrlSafe = base64ToUrlSafeBase64(base64Hash);
   const extra: HederaOperationExtra = {
+    ...(isValidExtra(operation.extra) ? operation.extra : {}),
     transactionId: response.transactionId.toString(),
   };
 

package/src/bridge/buildOptimisticOperation.integration.test.ts

@@ -0,0 +1,88 @@
+import BigNumber from "bignumber.js";
+import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { getEstimatedFees } from "./utils";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_KINDS } from "../constants";
+
+describe("buildOptimisticOperation", () => {
+  let estimatedFees: Record<"crypto" | "associate", BigNumber>;
+
+  beforeAll(async () => {
+    const mockedAccount = getMockedAccount();
+    const [crypto, associate] = await Promise.all([
+      getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer),
+      getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.TokenAssociate),
+    ]);
+
+    estimatedFees = { crypto, associate };
+  });
+
+  test("builds optimistic operation for token association", async () => {
+    const mockedAccount = getMockedAccount();
+    const mockedToken = getMockedTokenCurrency();
+    const mockedTransaction = getMockedTransaction({
+      amount: new BigNumber(0),
+      recipient: "0.0.1234",
+      properties: {
+        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
+        token: mockedToken,
+      },
+    });
+
+    const op = await buildOptimisticOperation({
+      account: mockedAccount,
+      transaction: mockedTransaction,
+    });
+
+    expect(op.type).toBe("ASSOCIATE_TOKEN");
+    expect(op.extra).toEqual({ associatedTokenId: mockedToken.contractAddress });
+    expect(op.fee).toEqual(estimatedFees.associate);
+    expect(op.senders).toContain(mockedAccount.freshAddress.toString());
+    expect(op.recipients).toContain("0.0.1234");
+  });
+
+  test("builds optimistic operation for coin", async () => {
+    const mockedAccount = getMockedAccount();
+    const mockedTransaction = getMockedTransaction({
+      amount: new BigNumber(123),
+      recipient: "0.0.5678",
+    });
+
+    const op = await buildOptimisticOperation({
+      account: mockedAccount,
+      transaction: mockedTransaction,
+    });
+
+    expect(op.type).toBe("OUT");
+    expect(op.fee).toEqual(estimatedFees.crypto);
+    expect(op.value).toEqual(new BigNumber(123));
+    expect(op.senders).toContain(mockedAccount.freshAddress.toString());
+    expect(op.recipients).toContain("0.0.5678");
+  });
+
+  test("builds optimistic operation for token", async () => {
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const tokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+    const parentAccount = getMockedAccount({ subAccounts: [tokenAccount] });
+    const mockedTransaction = getMockedTransaction({
+      subAccountId: tokenAccount.id,
+      amount: new BigNumber(123),
+      recipient: "0.0.9999",
+    });
+
+    const op = await buildOptimisticOperation({
+      account: parentAccount,
+      transaction: mockedTransaction,
+    });
+    const subOp = op.subOperations![0];
+
+    expect(op.type).toBe("FEES");
+    expect(op.subOperations).toHaveLength(1);
+    expect(subOp.type).toBe("OUT");
+    expect(subOp.value).toEqual(new BigNumber(123));
+    expect(subOp.accountId).toBe(tokenAccount.id);
+    expect(subOp.recipients).toContain("0.0.9999");
+  });
+});