@polymeshassociation/polymesh-sdk 16.0.0-beta.2 → 16.0.0-beta.3

package/base/PostTransactionValue.js

@@ -1,108 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostTransactionValue = void 0;
-const internal_1 = require("../internal");
-const types_1 = require("../types");
-/**
- * @hidden
- *
- * Represents a value or method that doesn't exist at the moment, but will exist once a certain transaction
- *   has been run
- */
-class PostTransactionValue {
-    // eslint-disable-next-line require-jsdoc
-    constructor(resolver, runCondition = () => true) {
-        this.resolved = false;
-        /**
-         * Array of PostTransactionValues spawned by this one via `transform` or `merge`. We use this to keep track
-         */
-        this.children = [];
-        this.resolver = resolver;
-        this.runCondition = runCondition;
-    }
-    /**
-     * Run the resolver function and assign its result to this object
-     */
-    run(receipt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.runCondition()) {
-                return;
-            }
-            const result = yield this.resolver(receipt);
-            this.resolved = true;
-            this._value = result;
-            yield Promise.all(this.children.map(child => child.run(receipt)));
-        });
-    }
-    /**
-     * Retrieve the resolved value
-     *
-     * @throws if the value is being accessed before the resolver function has run
-     */
-    get value() {
-        const { _value: value, resolved } = this;
-        if (!resolved) {
-            throw new internal_1.PolymeshError({
-                code: types_1.ErrorCode.FatalError,
-                message: 'Post Transaction Value accessed before the corresponding transaction was executed',
-            });
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return value;
-    }
-    /**
-     * Add a new PostTransactionValue to the children array to be run when this one runs
-     */
-    addChild(child) {
-        this.children.push(child);
-    }
-    /**
-     * Return a new PostTransactionValue that resolves to the value of this one processed by
-     *   the passed callback. The new PostTransactionValue is resolved when this one is resolved
-     */
-    transform(callback) {
-        const newResolver = () => {
-            return callback(this.value);
-        };
-        const child = new PostTransactionValue(newResolver);
-        this.addChild(child);
-        return child;
-    }
-    /**
-     * Merge this PostTransactionValue with another PostTransactionValue (or plain value), resulting in a new
-     *   PostTransactionValue that resolves once these two are resolved. The resolved value is the result of passing the
-     *   resolved values of both PostTransactionValues to the callback
-     */
-    merge(postValue, 
-    // cSpell: disable-next-line
-    callback) {
-        let newResolver;
-        let runCondition;
-        // do nothing on .run unless both underlying values have been resolved
-        if (postValue instanceof PostTransactionValue) {
-            newResolver = () => callback(this.value, postValue.value);
-            runCondition = () => this.resolved && postValue.resolved;
-        }
-        else {
-            newResolver = () => callback(this.value, postValue);
-            runCondition = () => this.resolved;
-        }
-        const child = new PostTransactionValue(newResolver, runCondition);
-        this.addChild(child);
-        if (postValue instanceof PostTransactionValue) {
-            postValue.addChild(child);
-        }
-        return child;
-    }
-}
-exports.PostTransactionValue = PostTransactionValue;
-//# sourceMappingURL=PostTransactionValue.js.map

package/base/PostTransactionValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostTransactionValue.js","sourceRoot":"","sources":["../../src/base/PostTransactionValue.ts"],"names":[],"mappings":";;;;;;;;;;;;AAEA,0CAA2C;AAC3C,oCAAoC;AAGpC;;;;;GAKG;AACH,MAAa,oBAAoB;IAc/B,yCAAyC;IACzC,YACE,QAAiE,EACjE,eAA8B,GAAY,EAAE,CAAC,IAAI;QAd3C,aAAQ,GAAG,KAAK,CAAC;QAMzB;;WAEG;QACK,aAAQ,GAAoC,EAAE,CAAC;QAOrD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACU,GAAG,CAAC,OAA2B;;YAC1C,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE;gBACxB,OAAO;aACR;YAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAC5C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;YAErB,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACpE,CAAC;KAAA;IAED;;;;OAIG;IACH,IAAW,KAAK;QACd,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAEzC,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,IAAI,wBAAa,CAAC;gBACtB,IAAI,EAAE,iBAAS,CAAC,UAAU;gBAC1B,OAAO,EACL,mFAAmF;aACtF,CAAC,CAAC;SACJ;QAED,oEAAoE;QACpE,OAAO,KAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,QAAQ,CAAC,KAAoC;QACnD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,SAAS,CAAW,QAAkC;QAC3D,MAAM,WAAW,GAAG,GAAa,EAAE;YACjC,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAErB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACI,KAAK,CACV,SAA+C;IAC/C,4BAA4B;IAC5B,QAAmD;QAEnD,IAAI,WAAW,CAAC;QAChB,IAAI,YAAY,CAAC;QAEjB,sEAAsE;QACtE,IAAI,SAAS,YAAY,oBAAoB,EAAE;YAC7C,WAAW,GAAG,GAAa,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;YACpE,YAAY,GAAG,GAAY,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC;SACnE;aAAM;YACL,WAAW,GAAG,GAAa,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC9D,YAAY,GAAG,GAAY,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC;SAC7C;QAED,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAClE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAErB,IAAI,SAAS,YAAY,oBAAoB,EAAE;YAC7C,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC3B;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AA/GD,oDA+GC"}

package/base/TransactionQueue.d.ts

@@ -1,142 +0,0 @@
-import { Context, PolymeshError, PolymeshTransactionBase } from "../internal";
-import { FeesBreakdown, TransactionQueueStatus } from "../types";
-import { MaybePostTransactionValue } from "../types/internal";
-/**
- * @hidden
- */
-declare type PolymeshTransactionArray<TransactionArgs extends unknown[][]> = {
-    [K in keyof TransactionArgs]: TransactionArgs[K] extends TransactionArgs[number] ? PolymeshTransactionBase<TransactionArgs[K]> : never;
-};
-/**
- * Class to manage procedural transaction queues
- */
-export declare class TransactionQueue<ProcedureReturnType = void, ReturnType = ProcedureReturnType, TransactionArgs extends unknown[][] = unknown[][]> {
-    /**
-     * transactions that will be run in the queue
-     */
-    transactions: PolymeshTransactionArray<TransactionArgs>;
-    /**
-     * status of the queue
-     */
-    status: TransactionQueueStatus;
-    /**
-     * optional error information
-     */
-    error?: PolymeshError;
-    /**
-     * @hidden
-     * internal queue of transactions to be run
-     */
-    private queue;
-    /**
-     * @hidden
-     * value
-     */
-    private procedureResult;
-    /**
-     * @hidden
-     * function that transforms the return type
-     */
-    private transformer;
-    /**
-     * @hidden
-     * internal event emitter to listen for status changes
-     */
-    private emitter;
-    /**
-     * @hidden
-     * whether the queue has run or not (prevents re-running)
-     */
-    private hasRun;
-    private context;
-    /**
-     * Create a transaction queue
-     *
-     * @param args.transactions - list of transactions to be run in this queue
-     * @param args.procedureResult - value that will be returned by the queue after it is run. It can be a {@link PostTransactionValue}
-     * @param args.transformer - function that transforms the procedure's return value before returning it after the queue is run
-     */
-    constructor(args: {
-        transactions: PolymeshTransactionArray<TransactionArgs>;
-        procedureResult: MaybePostTransactionValue<ProcedureReturnType>;
-        transformer?: (result: ProcedureReturnType) => Promise<ReturnType> | ReturnType;
-    }, context: Context);
-    /**
-     * Run the transactions in the queue in sequential order. If a transaction fails or the user refuses to sign it, one of two things can happen:
-     *
-     * 1) If `transaction.isCritical === true`, the entire queue fails and the corresponding error is stored in `this.error` as well as thrown
-     * 2) Otherwise, the queue continues executing and the error is stored in `transaction.error`
-     */
-    run(): Promise<ReturnType>;
-    /**
-     * Retrieve a lower bound of the fees required to execute this transaction queue.
-     *   Transaction fees can be higher at execution time for three reasons:
-     *
-     * - One or more transaction arguments depend on the result of another transaction in the queue.
-     *   This means fees can't be calculated for said transaction until previous transactions in the queue have run
-     * - Protocol or gas fees may vary between when this value is fetched and when the transaction is actually executed because of a
-     *   governance vote
-     *
-     * Transaction fees are broken down between those that have to be paid by the signing Account and
-     *   those that will be paid by third parties. In most cases, the entirety of the fees will be paid by
-     *   either the signing Account or a **single** third party Account
-     */
-    getMinFees(): Promise<FeesBreakdown>;
-    /**
-     * @hidden
-     *
-     * Return a breakdown of the queue's fees and which transactions are being subsidized
-     */
-    private _getMinFees;
-    /**
-     * Subscribe to status changes on the Transaction Queue
-     *
-     * @param listener - callback function that will be called whenever the Transaction Queue's status changes
-     *
-     * @returns unsubscribe function
-     */
-    onStatusChange(listener: (transactionQueue: this, err?: PolymeshError) => void): () => void;
-    /**
-     * Subscribe to status changes on individual transactions
-     *
-     * @param listener - callback function that will be called whenever the individual transaction's status changes
-     *
-     * @returns unsubscribe function
-     */
-    onTransactionStatusChange<Values extends unknown[]>(listener: (transaction: PolymeshTransactionBase<Values>, transactionQueue: this) => void): () => void;
-    /**
-     * Subscribe to the results of this queue being processed by the harvester (and as such, available to the middleware)
-     *
-     * @param listener - callback function that will be called whenever the middleware is updated with the latest data.
-     *   If there is an error (timeout or middleware offline) it will be passed to this callback
-     *
-     * @note this event will be fired even if the queue fails
-     * @returns unsubscribe function
-     * @throws if the middleware wasn't enabled when instantiating the SDK client
-     */
-    onProcessedByMiddleware(listener: (err?: PolymeshError) => void): () => void;
-    /**
-     * @hidden
-     */
-    private updateStatus;
-    /**
-     * @hidden
-     */
-    private executeTransactionQueue;
-    /**
-     * Poll the middleware every 2 seconds to see if it has already processed the
-     *   block that reflects the changes brought on by this queue being run. If so,
-     *   emit the corresponding event. After 5 retries (or if the middleware can't be reached),
-     *   the event is emitted with an error
-     *
-     * @note uses the middleware
-     */
-    private emitWhenMiddlewareIsSynced;
-    /**
-     * Check if balances and allowances (both third party and signing Account)
-     *   are sufficient to cover this queue's fees
-     */
-    private assertFeesCovered;
-}
-export {};
-//# sourceMappingURL=TransactionQueue.d.ts.map

package/base/TransactionQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionQueue.d.ts","sourceRoot":"","sources":["../../src/base/TransactionQueue.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAwB,oBAAmB;AAGnG,OAAO,EAGL,aAAa,EAGb,sBAAsB,EACvB,iBAAgB;AACjB,OAAO,EAAE,yBAAyB,EAAE,0BAAyB;AAa7D;;GAEG;AACH,aAAK,wBAAwB,CAAC,eAAe,SAAS,OAAO,EAAE,EAAE,IAAI;KAClE,CAAC,IAAI,MAAM,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,SAAS,eAAe,CAAC,MAAM,CAAC,GAC5E,uBAAuB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GAC3C,KAAK;CACV,CAAC;AAEF;;GAEG;AACH,qBAAa,gBAAgB,CAC3B,mBAAmB,GAAG,IAAI,EAC1B,UAAU,GAAG,mBAAmB,EAChC,eAAe,SAAS,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE;IAEjD;;OAEG;IACI,YAAY,EAAE,wBAAwB,CAAC,eAAe,CAAC,CAAC;IAE/D;;OAEG;IACI,MAAM,EAAE,sBAAsB,CAA+B;IAEpE;;OAEG;IACI,KAAK,CAAC,EAAE,aAAa,CAAC;IAE7B;;;OAGG;IACH,OAAO,CAAC,KAAK,CAA8D;IAE3E;;;OAGG;IACH,OAAO,CAAC,eAAe,CAAiD;IAExE;;;OAGG;IACH,OAAO,CAAC,WAAW,CAA6E;IAEhG;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAe;IAE9B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAU;IAExB,OAAO,CAAC,OAAO,CAAU;IAEzB;;;;;;OAMG;gBAED,IAAI,EAAE;QACJ,YAAY,EAAE,wBAAwB,CAAC,eAAe,CAAC,CAAC;QACxD,eAAe,EAAE,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;QAChE,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;KACjF,EACD,OAAO,EAAE,OAAO;IAwBlB;;;;;OAKG;IACU,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC;IAwCvC;;;;;;;;;;;;OAYG;IACU,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC;IAUjD;;;;OAIG;YACW,WAAW;IA8FzB;;;;;;OAMG;IACI,cAAc,CACnB,QAAQ,EAAE,CAAC,gBAAgB,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,aAAa,KAAK,IAAI,GAC9D,MAAM,IAAI;IAQb;;;;;;OAMG;IACI,yBAAyB,CAAC,MAAM,SAAS,OAAO,EAAE,EACvD,QAAQ,EAAE,CAAC,WAAW,EAAE,uBAAuB,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,IAAI,KAAK,IAAI,GACvF,MAAM,IAAI;IAQb;;;;;;;;;OASG;IACI,uBAAuB,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI;IAenF;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;YACW,uBAAuB;IAkBrC;;;;;;;OAOG;YACW,0BAA0B;IAyDxC;;;OAGG;YACW,iBAAiB;CAkEhC"}

package/base/TransactionQueue.js

@@ -1,420 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionQueue = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const bluebird_1 = __importDefault(require("bluebird"));
-const events_1 = require("events");
-const lodash_1 = require("lodash");
-const internal_1 = require("../internal");
-const queries_1 = require("../middleware/queries");
-const types_1 = require("../types");
-const internal_2 = require("../utils/internal");
-/**
- * @hidden
- */
-var Event;
-(function (Event) {
-    Event["StatusChange"] = "StatusChange";
-    Event["TransactionStatusChange"] = "TransactionStatusChange";
-    Event["ProcessedByMiddleware"] = "ProcessedByMiddleware";
-})(Event || (Event = {}));
-/**
- * Class to manage procedural transaction queues
- */
-class TransactionQueue {
-    /**
-     * Create a transaction queue
-     *
-     * @param args.transactions - list of transactions to be run in this queue
-     * @param args.procedureResult - value that will be returned by the queue after it is run. It can be a {@link PostTransactionValue}
-     * @param args.transformer - function that transforms the procedure's return value before returning it after the queue is run
-     */
-    constructor(args, context) {
-        /**
-         * status of the queue
-         */
-        this.status = types_1.TransactionQueueStatus.Idle;
-        /**
-         * @hidden
-         * internal queue of transactions to be run
-         */
-        this.queue = [];
-        const { transactions, procedureResult, transformer = (val) => __awaiter(this, void 0, void 0, function* () { return val; }), } = args;
-        this.emitter = new events_1.EventEmitter();
-        this.procedureResult = procedureResult;
-        this.hasRun = false;
-        this.context = context;
-        this.transactions = [];
-        this.transformer = transformer;
-        transactions.forEach(transaction => {
-            transaction.onStatusChange(updatedTransaction => {
-                this.emitter.emit(Event.TransactionStatusChange, updatedTransaction, this);
-            });
-            this.transactions.push(transaction);
-        });
-    }
-    /**
-     * Run the transactions in the queue in sequential order. If a transaction fails or the user refuses to sign it, one of two things can happen:
-     *
-     * 1) If `transaction.isCritical === true`, the entire queue fails and the corresponding error is stored in `this.error` as well as thrown
-     * 2) Otherwise, the queue continues executing and the error is stored in `transaction.error`
-     */
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasRun) {
-                throw new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.General,
-                    message: 'Cannot re-run a Transaction Queue',
-                });
-            }
-            yield this.assertFeesCovered();
-            this.queue = [...this.transactions];
-            this.updateStatus(types_1.TransactionQueueStatus.Running);
-            let procRes;
-            let res;
-            try {
-                yield this.executeTransactionQueue();
-                this.updateStatus(types_1.TransactionQueueStatus.Succeeded);
-                const { procedureResult } = this;
-                if (procedureResult instanceof internal_1.PostTransactionValue) {
-                    procRes = procedureResult.value;
-                }
-                else {
-                    procRes = procedureResult;
-                }
-                res = yield this.transformer(procRes);
-            }
-            catch (err) {
-                this.error = err;
-                this.updateStatus(types_1.TransactionQueueStatus.Failed);
-                throw err;
-            }
-            finally {
-                this.hasRun = true;
-                yield this.emitWhenMiddlewareIsSynced();
-            }
-            return res;
-        });
-    }
-    /**
-     * Retrieve a lower bound of the fees required to execute this transaction queue.
-     *   Transaction fees can be higher at execution time for three reasons:
-     *
-     * - One or more transaction arguments depend on the result of another transaction in the queue.
-     *   This means fees can't be calculated for said transaction until previous transactions in the queue have run
-     * - Protocol or gas fees may vary between when this value is fetched and when the transaction is actually executed because of a
-     *   governance vote
-     *
-     * Transaction fees are broken down between those that have to be paid by the signing Account and
-     *   those that will be paid by third parties. In most cases, the entirety of the fees will be paid by
-     *   either the signing Account or a **single** third party Account
-     */
-    getMinFees() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _a = yield this._getMinFees(), { 
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            subsidizedTransactions } = _a, rest = __rest(_a, ["subsidizedTransactions"]);
-            return rest;
-        });
-    }
-    /**
-     * @hidden
-     *
-     * Return a breakdown of the queue's fees and which transactions are being subsidized
-     */
-    _getMinFees() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { context, transactions } = this;
-            // get the fees and paying Account for each transaction in the queue
-            const allFees = yield bluebird_1.default.map(transactions, (transaction) => __awaiter(this, void 0, void 0, function* () {
-                const [payingAccount, fees] = yield Promise.all([
-                    transaction.getPayingAccount(),
-                    transaction.getFees(),
-                ]);
-                if (!fees) {
-                    return null;
-                }
-                if (payingAccount) {
-                    return {
-                        fees,
-                        payingAccount,
-                    };
-                }
-                return {
-                    fees,
-                };
-            }));
-            const addFees = (a, b) => {
-                return {
-                    protocol: a.protocol.plus(b.protocol),
-                    gas: a.gas.plus(b.gas),
-                };
-            };
-            // Account address -> fee data (for efficiency)
-            const breakdownByAccount = {};
-            // fees for the signing Account
-            let accountFees = {
-                protocol: new bignumber_js_1.default(0),
-                gas: new bignumber_js_1.default(0),
-            };
-            const subsidizedTransactions = [];
-            // compile the fees and other data for each paying Account (and the signing Account as well)
-            const eachPromise = bluebird_1.default.each(allFees, (transactionFees, index) => __awaiter(this, void 0, void 0, function* () {
-                if (!transactionFees) {
-                    return;
-                }
-                const { fees, payingAccount } = transactionFees;
-                if (!payingAccount) {
-                    // payingAccount === null means the signing Account has to pay
-                    accountFees = addFees(accountFees, fees);
-                }
-                else {
-                    const { account, type } = payingAccount;
-                    const { address } = account;
-                    const thirdPartyData = breakdownByAccount[address];
-                    if (type === types_1.PayingAccountType.Subsidy) {
-                        subsidizedTransactions.push(transactions[index]);
-                    }
-                    if (!thirdPartyData) {
-                        // first time encountering this third party Account, we must populate the initial values
-                        const { free: balance } = yield account.getBalance();
-                        breakdownByAccount[address] = Object.assign(Object.assign({}, payingAccount), { balance,
-                            fees });
-                    }
-                    else {
-                        // already encountered the Account before, just add the fees
-                        thirdPartyData.fees = addFees(thirdPartyData.fees, fees);
-                    }
-                }
-            }));
-            const { free: accountBalance } = yield context.accountBalance();
-            yield eachPromise;
-            const thirdPartyFees = (0, lodash_1.values)(breakdownByAccount);
-            return {
-                thirdPartyFees,
-                accountBalance,
-                accountFees,
-                subsidizedTransactions,
-            };
-        });
-    }
-    /**
-     * Subscribe to status changes on the Transaction Queue
-     *
-     * @param listener - callback function that will be called whenever the Transaction Queue's status changes
-     *
-     * @returns unsubscribe function
-     */
-    onStatusChange(listener) {
-        this.emitter.on(Event.StatusChange, listener);
-        return () => {
-            this.emitter.removeListener(Event.StatusChange, listener);
-        };
-    }
-    /**
-     * Subscribe to status changes on individual transactions
-     *
-     * @param listener - callback function that will be called whenever the individual transaction's status changes
-     *
-     * @returns unsubscribe function
-     */
-    onTransactionStatusChange(listener) {
-        this.emitter.on(Event.TransactionStatusChange, listener);
-        return () => {
-            this.emitter.removeListener(Event.TransactionStatusChange, listener);
-        };
-    }
-    /**
-     * Subscribe to the results of this queue being processed by the harvester (and as such, available to the middleware)
-     *
-     * @param listener - callback function that will be called whenever the middleware is updated with the latest data.
-     *   If there is an error (timeout or middleware offline) it will be passed to this callback
-     *
-     * @note this event will be fired even if the queue fails
-     * @returns unsubscribe function
-     * @throws if the middleware wasn't enabled when instantiating the SDK client
-     */
-    onProcessedByMiddleware(listener) {
-        if (!this.context.isMiddlewareEnabled()) {
-            throw new internal_1.PolymeshError({
-                code: types_1.ErrorCode.General,
-                message: 'Cannot subscribe without an enabled middleware connection',
-            });
-        }
-        this.emitter.on(Event.ProcessedByMiddleware, listener);
-        return () => {
-            this.emitter.removeListener(Event.ProcessedByMiddleware, listener);
-        };
-    }
-    /**
-     * @hidden
-     */
-    updateStatus(status) {
-        this.status = status;
-        switch (status) {
-            case types_1.TransactionQueueStatus.Running:
-            case types_1.TransactionQueueStatus.Succeeded: {
-                this.emitter.emit(Event.StatusChange, this);
-                return;
-            }
-            case types_1.TransactionQueueStatus.Failed: {
-                this.emitter.emit(Event.StatusChange, this, this.error);
-            }
-        }
-    }
-    /**
-     * @hidden
-     */
-    executeTransactionQueue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const nextTransaction = this.queue.shift();
-            if (!nextTransaction) {
-                return;
-            }
-            try {
-                yield nextTransaction.run();
-            }
-            catch (err) {
-                if (nextTransaction.isCritical) {
-                    throw err;
-                }
-            }
-            yield this.executeTransactionQueue();
-        });
-    }
-    /**
-     * Poll the middleware every 2 seconds to see if it has already processed the
-     *   block that reflects the changes brought on by this queue being run. If so,
-     *   emit the corresponding event. After 5 retries (or if the middleware can't be reached),
-     *   the event is emitted with an error
-     *
-     * @note uses the middleware
-     */
-    emitWhenMiddlewareIsSynced() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { context } = this;
-            if (!context.isMiddlewareEnabled()) {
-                return;
-            }
-            const blockNumber = yield context.getLatestBlock();
-            let done = false;
-            /*
-             * We do not await this promise because it is supposed to run in the background, and
-             * any errors encountered are emitted. If the user isn't listening, they shouldn't
-             * care about middleware (or other) errors anyway
-             */
-            bluebird_1.default.each((0, lodash_1.range)(6), (i) => __awaiter(this, void 0, void 0, function* () {
-                if (done) {
-                    return;
-                }
-                try {
-                    const { data: { latestBlock: { id: processedBlock }, }, } = yield context.queryMiddleware((0, queries_1.latestProcessedBlock)());
-                    if (blockNumber.lte(processedBlock)) {
-                        done = true;
-                        this.emitter.emit(Event.ProcessedByMiddleware);
-                        return;
-                    }
-                }
-                catch (err) { }
-                if (i === 5) {
-                    this.emitter.emit(Event.ProcessedByMiddleware, new internal_1.PolymeshError({ code: types_1.ErrorCode.MiddlewareError, message: 'Timed out' }));
-                }
-                return (0, internal_2.delay)(2000);
-            })).catch(
-            /* istanbul ignore next: very hard to test, extreme edge case */
-            err => {
-                this.emitter.emit(Event.ProcessedByMiddleware, new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.UnexpectedError,
-                    message: err.message || 'Unexpected error',
-                }));
-            });
-        });
-    }
-    /**
-     * Check if balances and allowances (both third party and signing Account)
-     *   are sufficient to cover this queue's fees
-     */
-    assertFeesCovered() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const breakdown = yield this._getMinFees();
-            const { accountBalance, accountFees, thirdPartyFees, subsidizedTransactions } = breakdown;
-            const unsupportedTransactions = subsidizedTransactions.filter(transaction => !transaction.supportsSubsidy());
-            if (unsupportedTransactions.length) {
-                throw new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.UnmetPrerequisite,
-                    message: 'Some of the transactions in the queue cannot be run with a subsidized Account',
-                    data: {
-                        unsupportedTransactions,
-                    },
-                });
-            }
-            const calculateTotal = ({ protocol, gas }) => protocol.plus(gas);
-            const noThirdPartyAllowance = [];
-            const noThirdPartyBalance = [];
-            thirdPartyFees.forEach(data => {
-                const { allowance, balance, fees } = data;
-                const total = calculateTotal(fees);
-                if (balance.lt(total)) {
-                    noThirdPartyBalance.push(data);
-                }
-                if (allowance === null || allowance === void 0 ? void 0 : allowance.lt(total)) {
-                    noThirdPartyAllowance.push(data);
-                }
-            });
-            if (noThirdPartyAllowance.length) {
-                throw new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.InsufficientBalance,
-                    message: "Not enough POLYX third party allowance to pay for this procedure's fees",
-                    data: {
-                        thirdPartyFees: noThirdPartyAllowance,
-                    },
-                });
-            }
-            if (noThirdPartyBalance.length) {
-                throw new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.InsufficientBalance,
-                    message: "Not enough POLYX third party balance to pay for this procedure's fees",
-                    data: {
-                        thirdPartyFees: noThirdPartyBalance,
-                    },
-                });
-            }
-            const totalFees = calculateTotal(accountFees);
-            if (accountBalance.lt(totalFees)) {
-                throw new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.InsufficientBalance,
-                    message: "Not enough POLYX balance to pay for this procedure's fees",
-                    data: {
-                        balance: accountBalance,
-                        fees: accountFees,
-                    },
-                });
-            }
-        });
-    }
-}
-exports.TransactionQueue = TransactionQueue;
-//# sourceMappingURL=TransactionQueue.js.map