@pushchain/core 6.0.2 → 6.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "6.0.2",
+  "version": "6.0.3",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

package/src/lib/orchestrator/internals/tx-transformer.js

@@ -98,10 +98,10 @@ function reconstructProgressEvents(universalTxResponse, universalTxData) {
     // omitted from reconstruction because R1 doesn't register a UniversalTx
     // on Push Chain, so `universalTxData` is usually undefined here and we
     // have no reliable signal to tell the three paths apart. Callers who want
-    // the full live sequence should either register `progressHook` at
-    // `initialize()` time (client-level) or call `tx.progressHook(cb)` after
-    // sendTransaction — both deliver the full stream from the execute-phase
-    // event buffer.
+    // the full live sequence should register a progress hook at initialize
+    // time, pass `sendTransaction(params, { progressHook })`, or call
+    // `tx.progressHook(cb)` after sendTransaction — all deliver the full stream
+    // from the execute-phase event buffer.
     const events = [];
     const originParts = universalTxResponse.origin.split(':');
     const chainNamespace = originParts.length >= 2 ? `${originParts[0]}:${originParts[1]}` : originParts[0];

package/src/lib/orchestrator/orchestrator.js

@@ -131,10 +131,33 @@ class Orchestrator {
      */
     execute(params, options) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             if (options) {
                 params = Object.assign(Object.assign({}, params), { options: Object.assign(Object.assign({}, params.options), options) });
             }
+            const perCallHook = (_a = params.options) === null || _a === void 0 ? void 0 : _a.progressHook;
+            const originalExecuteHook = this.progressHook;
+            const currentHook = this.progressHook;
+            const shouldWrapPerCallHook = !!perCallHook &&
+                perCallHook !== currentHook &&
+                (currentHook === null || currentHook === void 0 ? void 0 : currentHook.__pushPerCallHook) !== perCallHook;
+            const attachPerCallHookForWait = (response) => {
+                if (perCallHook && response._setProgressHookNoReplay) {
+                    response._setProgressHookNoReplay(perCallHook);
+                }
+                return response;
+            };
+            if (shouldWrapPerCallHook) {
+                const baseHook = this.progressHook;
+                const wrappedHook = ((event) => {
+                    if (baseHook && baseHook !== perCallHook) {
+                        baseHook(event);
+                    }
+                    perCallHook(event);
+                });
+                wrappedHook.__pushPerCallHook = perCallHook;
+                this.progressHook = wrappedHook;
+            }
             // Snapshot the caller's active route — `executeMultiChain` recurses into
             // this same method for R2/R3's inner Push-side execution, and without
             // snapshot/restore the recursive `detectRoute(params)` would clobber the
@@ -146,7 +169,7 @@ class Orchestrator {
             try {
                 detectedRoute = (0, route_detector_1.detectRoute)(params);
             }
-            catch (_e) {
+            catch (_f) {
                 detectedRoute = route_detector_1.TransactionRoute.UOA_TO_PUSH;
             }
             // Don't downgrade an outer R2/R3/R4 route when the recursive inner call
@@ -164,14 +187,14 @@ class Orchestrator {
                 // Lazy UEA upgrade check
                 try {
                     if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
-                        yield ((_a = this.accountStatusReadyPromise) !== null && _a !== void 0 ? _a : this.getAccountStatus());
+                        yield ((_b = this.accountStatusReadyPromise) !== null && _b !== void 0 ? _b : this.getAccountStatus());
                     }
                     // If background resolved but cache still empty (timeout/error), fetch fresh
                     if (!this.accountStatusCache || !this.accountStatusCache.uea.loaded) {
                         yield this.getAccountStatus();
                     }
-                    if (((_b = this.accountStatusCache) === null || _b === void 0 ? void 0 : _b.uea.deployed) &&
-                        ((_c = this.accountStatusCache) === null || _c === void 0 ? void 0 : _c.uea.requiresUpgrade)) {
+                    if (((_c = this.accountStatusCache) === null || _c === void 0 ? void 0 : _c.uea.deployed) &&
+                        ((_d = this.accountStatusCache) === null || _d === void 0 ? void 0 : _d.uea.requiresUpgrade)) {
                         yield this.upgradeAccount({ progressHook: this.progressHook });
                     }
                 }
@@ -179,10 +202,10 @@ class Orchestrator {
                     (0, internals_1.printLog)(this.ctx, `Lazy UEA upgrade check failed: ${err instanceof Error ? err.message : String(err)}. Proceeding with transaction.`);
                 }
                 // Check if this is a multi-chain request (has ChainTarget or from.chain)
-                const isMultiChain = (0, route_detector_1.isChainTarget)(params.to) || ('from' in params && ((_d = params.from) === null || _d === void 0 ? void 0 : _d.chain));
+                const isMultiChain = (0, route_detector_1.isChainTarget)(params.to) || ('from' in params && ((_e = params.from) === null || _e === void 0 ? void 0 : _e.chain));
                 if (isMultiChain) {
                     try {
-                        return yield (0, internals_1.executeMultiChain)(this.ctx, params, this.execute.bind(this));
+                        return attachPerCallHookForWait(yield (0, internals_1.executeMultiChain)(this.ctx, params, this.execute.bind(this)));
                     }
                     catch (err) {
                         // R2/R3/R4 outer catch — fires the route-correct terminal failure
@@ -230,11 +253,11 @@ class Orchestrator {
                 try {
                     const rcb = () => this._getResponseCallbacks();
                     if (execute.funds) {
-                        return !hasData
+                        return attachPerCallHookForWait(!hasData
                             ? yield (0, internals_1.executeFundsOnly)(this.ctx, execute, eventBuffer, rcb)
-                            : yield (0, internals_1.executeFundsWithPayload)(this.ctx, execute, eventBuffer, rcb);
+                            : yield (0, internals_1.executeFundsWithPayload)(this.ctx, execute, eventBuffer, rcb));
                     }
-                    return yield (0, internals_1.executeStandardPayload)(this.ctx, execute, eventBuffer, rcb);
+                    return attachPerCallHookForWait(yield (0, internals_1.executeStandardPayload)(this.ctx, execute, eventBuffer, rcb));
                 }
                 catch (err) {
                     const errMessage = err instanceof Error
@@ -277,6 +300,9 @@ class Orchestrator {
                 }
             }
             finally {
+                if (shouldWrapPerCallHook) {
+                    this.progressHook = originalExecuteHook;
+                }
                 // Restore the caller's route so a recursive inner R1 execute doesn't
                 // leak its UOA_TO_PUSH route back to the outer R2/R3 frame.
                 this.currentRoute = previousRoute;

package/src/lib/orchestrator/orchestrator.types.d.ts

@@ -38,6 +38,15 @@ export interface TransactionExecutionOptions {
      * - true: emit the failure hook, throw InsufficientUEABalanceError, and stop
      */
     enforceGasCheck?: boolean;
+    /**
+     * Optional per-call progress callback for sendTransaction().
+     * Additive with the init-time `progressHook` passed to `PushChain.initialize`:
+     * both hooks receive every `ProgressEvent` emitted during this call. The
+     * callback is also registered on the returned response for wait-phase
+     * progress without replaying already-fired events. Dedups by reference if it
+     * matches the init-time hook.
+     */
+    progressHook?: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void;
 }
 export type ExecuteParams = {
     /**
@@ -184,10 +193,11 @@ export interface UniversalTxResponse {
     progressHook: (callback: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void) => void;
     /**
      * @internal Register a wait-phase progressHook without replaying buffered
-     * events. Used by `trackTransaction()` to auto-attach the caller's per-call
-     * progressHook so `tracked.wait()` can deliver wait-phase events (209-xx /
-     * 299-xx / 399-xx) to the same callback — without re-emitting the
-     * reconstructed execute-phase stream that trackTransaction already fired.
+     * events. Used by `sendTransaction(..., { progressHook })` and
+     * `trackTransaction()` to auto-attach the caller's per-call progressHook so
+     * `.wait()` can deliver wait-phase events (209-xx / 299-xx / 399-xx) to the
+     * same callback — without re-emitting the execute/reconstructed stream that
+     * already fired.
      */
     _setProgressHookNoReplay?: (callback: (event: import('../progress-hook/progress-hook.types').ProgressEvent) => void) => void;
     type: string;

package/src/lib/push-chain/push-chain.d.ts

@@ -71,6 +71,12 @@ export declare class PushChain {
          * @param options.enforceGasCheck - Defaults to false. When true, the
          *   SDK stops on pre-flight gas/balance shortfall instead of warning
          *   and proceeding.
+         * @param options.progressHook - Optional per-call progress callback.
+         *   Additive with the init-time `progressHook` passed to `initialize`:
+         *   both hooks receive every `ProgressEvent` emitted during this call.
+         *   The callback is also registered on the returned response for wait()
+         *   progress without replaying already-fired events. Dedups by reference
+         *   if it matches the init-time hook.
          */
         sendTransaction: Orchestrator['execute'];
         /**