__tests__/assets/globals.d.ts

 // We only want to import types here!
 import type beekeeperFactoryType from "@hiveio/beekeeper/web";
+import type Wax from "@hiveio/wax";
+
 import type WorkerBee from "../../dist/bundle/index";
 
 export type TEnvType = "web" | "node";
@@ -8,6 +10,7 @@ export type TEnvType = "web" | "node";
 export interface IWorkerBeeGlobals {
   beekeeperFactory: typeof beekeeperFactoryType;
   WorkerBee: typeof WorkerBee;
+  wax: typeof Wax;
 }
 
 declare global {

__tests__/assets/globals.js

@@ -2,15 +2,18 @@
 globalThis.createTestFor = async function createTestFor(env) {
   const locWorkerBee = env === "web" ? "../../dist/bundle/index.js" : "../../dist/bundle/index.js";
   const locBeekeeper = env === "web" ? "@hiveio/beekeeper/web" : "@hiveio/beekeeper/node";
+  const locWax = env === "web" ? "@hiveio/wax/web" : "@hiveio/wax/node";
 
   // Import required libraries env-dependent
   const wb = await import(locWorkerBee);
   const beekeeper = await import(locBeekeeper);
+  const wax = await import(locWax);
 
   // Provide results
   return {
     beekeeperFactory: beekeeper.default,
-    WorkerBee: wb.default
+    WorkerBee: wb.default,
+    wax
   };
 };
 

__tests__/assets/test.html

@@ -10,6 +10,7 @@
     {
       "imports": {
         "@hiveio/wax": "/node_modules/@hiveio/wax/wasm/dist/bundle/web.js",
+        "@hiveio/wax/web": "/node_modules/@hiveio/wax/wasm/dist/bundle/web.js",
         "@hiveio/beekeeper/web": "/node_modules/@hiveio/beekeeper/dist/bundle/web.js"
       }
     }

__tests__/detailed/bot_events.ts

 /* eslint-disable no-console */
 
-
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import type { ApiAccount } from "@hiveio/wax";
+import type { ReplyOperation, ApiAccount } from "@hiveio/wax";
 import { expect } from "@playwright/test";
 import { ChromiumBrowser, ConsoleMessage, chromium } from "playwright";
 
 import type { IStartConfiguration } from "../../src/bot";
+import type { IBroadcastData, ITransactionData } from "../../src/index";
+
 import { test } from "../assets/jest-helper";
 
 
@@ -37,6 +38,81 @@ test.describe("WorkerBee Bot events test", () => {
     });
   });
 
+  test("Allow to broadcast to mirronet chain", async({ workerbeeTest }) => {
+    const broadcastTest = await workerbeeTest(async({ WorkerBee, wax, beekeeperFactory }) => {
+
+      /*
+       * Prepare helper WorkerBee instance just to provide IHiveChainInterface instance.
+       * It is a problem in PW tests to reference whole wax, since its dependencies need to be declared at importmap in test.html
+       */
+      const customWaxConfig = { apiEndpoint: "https://api.fake.openhive.network", chainId: "42" };
+      const customConfig: IStartConfiguration = { chainOptions: customWaxConfig };
+
+      const chainOwner = new WorkerBee(customConfig);
+      // Call start just to initialize chain member in WorkerBee object.
+      await chainOwner.start();
+      // Stop does not affect chain property, so we can avoid making ineffective api calls.
+      chainOwner.stop();
+
+      const localChain = chainOwner.chain!;
+
+      const bot = new WorkerBee({ explicitChain: localChain });
+
+      const newTx = await localChain.createTransaction();
+
+      newTx.pushOperation(new wax.ReplyOperation({author: "gtg", permlink: `re-${Date.now()}`, parentAuthor: "hbd.funder",
+        parentPermlink: "re-upvote-this-post-to-fund-hbdstabilizer-20250312t045515z", title: "test", body: "Awesome test!",
+        maxAcceptedPayout: localChain.hbdCoins(1000000), percentHbd: 9000, allowVotes: true, allowCurationRewards: true}));
+
+      const bkInstance = await beekeeperFactory({inMemory: true});
+      const bkSession = bkInstance.createSession("salt and pepper");
+
+      const {wallet} = await bkSession.createWallet("temp", "pass", true);
+      const publicKey = await wallet.importKey("5JNHfZYKGaomSFvd4NUdQ9qMcEAC43kujbfjueTHpVapX1Kzq2n");
+
+      /// Intentionally sign using legacy method
+      const legacySigDigest = newTx.legacy_sigDigest;
+      const signature = await wallet.signDigest(publicKey, legacySigDigest);
+      newTx.sign(signature);
+
+      let signatureIsMatching: boolean = false;
+
+      await Promise.race([
+        /* eslint-disable-next-line no-async-promise-executor */
+        new Promise<void>(async res => {
+          await bot.start();
+
+          const broadcastResultObserver = await bot.broadcast(newTx, { throwAfter: "+20s"});
+
+          const txObserver = broadcastResultObserver.subscribe({
+            next (data: IBroadcastData) {
+              console.log(`Received broadcast data: ${JSON.stringify(data.transaction)}`);
+              if(data.transaction.signatures[0] !== signature)
+                throw new Error("Invalid signature in broadcast result");
+
+              signatureIsMatching = true;
+              txObserver.unsubscribe();
+              res();
+            },
+            error(err) {
+              console.error(err);
+              throw new Error("Transaction broadcast failure");
+            }
+          });
+        }),
+        new Promise(res => { setTimeout(res, 15000); })
+      ]);
+
+      bot.delete();
+      chainOwner.delete();
+
+      return signatureIsMatching;
+    });
+
+    expect(broadcastTest).toEqual(true);
+  });
+
+
   test("Allow to pass explicit chain", async({ workerbeeTest }) => {
     const explicitChainTest = await workerbeeTest(async({ WorkerBee }) => {
 

src/bot.ts

@@ -103,10 +103,14 @@ export class WorkerBee implements IWorkerBee {
 
         const listener = txObserver.provideBlockHeaderData().subscribe({
           next(val) {
-            observer.next?.({
-              transaction: val.transactions[apiTx.id]!,
-              block: val.block
-            });
+            const transaction = val.transactions[txId] ?? val.transactions[legacyId]!;
+            if( transaction!== undefined) {
+              listener.unsubscribe();
+              observer.next?.({
+                transaction,
+                block: val.block
+              });
+            }
           },
           error(val) {
             observer.error?.(val);