@polymeshassociation/polymesh-sdk 15.0.1 → 15.1.0-alpha.1

package/base/PolymeshTransactionBase.d.ts

@@ -1,16 +1,20 @@
 /// <reference types="node" />
 import { SubmittableExtrinsic } from '@polkadot/api/types';
-import { DispatchError } from '@polkadot/types/interfaces';
+import { SpRuntimeDispatchError } from "../polkadot/types-lookup.ts";
 import { ISubmittableResult, Signer as PolkadotSigner } from '@polkadot/types/types';
 import BigNumber from 'bignumber.js';
 import { EventEmitter } from 'events';
 import { Context, Identity, PolymeshError } from "../internal";
-import { Fees, PayingAccount, TransactionStatus } from "../types";
-import { BaseTransactionSpec, PostTransactionValueArray } from "../types/internal";
+import { GenericPolymeshTransaction, PayingAccountFees, TransactionStatus, UnsubCallback } from "../types";
+import { BaseTransactionSpec, MaybeResolverFunction, TransactionSigningData } from "../types/internal";
 /**
  * Wrapper class for a Polymesh Transaction
  */
-export declare abstract class PolymeshTransactionBase<Values extends unknown[] = unknown[]> {
+export declare abstract class PolymeshTransactionBase<ReturnValue = void, TransformedReturnValue = ReturnValue> {
+    /**
+     * @hidden
+     */
+    static toTransactionSpec<R, T>(transaction: PolymeshTransactionBase<R, T>): BaseTransactionSpec<R, T>;
     /**
      * current status of the transaction
      */
@@ -39,10 +43,6 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
      * number of the block where this transaction resides (status: `Succeeded`, `Failed`)
      */
     blockNumber?: BigNumber;
-    /**
-     * whether this transaction failing makes the entire transaction queue fail or not
-     */
-    isCritical: boolean;
     /**
      * @hidden
      *
@@ -53,9 +53,9 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
     /**
      * @hidden
      *
-     * wrappers for values that will exist after this transaction has executed
+     * function that transforms the transaction's return value before returning it after it is run
      */
-    protected postValues: PostTransactionValueArray<Values>;
+    protected resolver: MaybeResolverFunction<ReturnValue>;
     /**
      * @hidden
      *
@@ -77,20 +77,27 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
     /**
      * @hidden
      *
-     * used by procedures to set the fee manually in case the protocol op can't be
-     *   dynamically generated from the transaction name, or a specific procedure has
-     *   special rules for calculating them
+     * function that transforms the return value to another type. Useful when using the same
+     *   Procedure for different endpoints which are supposed to return different values
      */
-    protected protocolFee?: BigNumber;
+    protected transformer?: (result: ReturnValue) => Promise<TransformedReturnValue> | TransformedReturnValue;
     protected context: Context;
     /**
      * @hidden
+     * whether the queue has run or not (prevents re-running)
      */
-    constructor(transactionSpec: BaseTransactionSpec<Values>, context: Context);
+    private hasRun;
     /**
-     * Run the transaction and update its status
+     * @hidden
      */
-    run(): Promise<void>;
+    constructor(transactionSpec: BaseTransactionSpec<ReturnValue, TransformedReturnValue> & TransactionSigningData, context: Context);
+    /**
+     * Run the transaction, update its status and return a result if applicable.
+     *   Certain transactions create Entities on the blockchain, and those Entities are returned
+     *   for convenience. For example, when running a transaction that creates an Asset, the Asset itself
+     *   is returned
+     */
+    run(): Promise<TransformedReturnValue>;
     /**
      * @hidden
      *
@@ -105,25 +112,34 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
      *
      * @returns unsubscribe function
      */
-    onStatusChange(listener: (transaction: this) => void): () => void;
+    onStatusChange(listener: (transaction: GenericPolymeshTransaction<ReturnValue, TransformedReturnValue>) => void): UnsubCallback;
     /**
-     * Retrieve the Account that would pay fees for the transaction if it was run at this moment, as well as the total amount that can be
-     *   charged to it (allowance). A null allowance means that there is no limit to that amount
+     * Retrieve a breakdown of the fees required to run this transaction, as well as the Account responsible for paying them
+     *
+     * @note these values might be inaccurate if the transaction is run at a later time. This can be due to a governance vote or other
+     *   chain related factors (like modifications to a specific subsidizer relationship or a chain upgrade)
+     */
+    getTotalFees(): Promise<PayingAccountFees>;
+    /**
+     * Subscribe to the results of this transaction being processed by the indexing service (and as such, available to the middleware)
      *
-     * A null return value signifies that the caller Account would pay the fees
+     * @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 value might change if, before running the transaction, the caller Account enters (or leaves)
-     *   a subsidizer relationship
+     * @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
      */
-    getPayingAccount(): Promise<PayingAccount | null>;
+    onProcessedByMiddleware(listener: (err?: PolymeshError) => void): UnsubCallback;
     /**
-     * Get all (protocol and gas) fees associated with this transaction. Returns null
-     * if the transaction is not ready yet (this can happen if it depends on the execution of a
-     * previous transaction in the queue)
+     * Poll the middleware every 2 seconds to see if it has already processed the
+     *   block that reflects the changes brought on by this transaction 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 this value might change if the transaction is run at a later time. This can be due to a governance vote
+     * @note uses the middleware
      */
-    getFees(): Promise<Fees | null>;
+    private emitWhenMiddlewareIsSynced;
     /**
      * @hidden
      */
@@ -133,7 +149,7 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
      *   AND the caller is being subsidized by a third party, the transaction can't be executed and trying
      *   to do so will result in an error
      *
-     * @note this depends on the type of transaction itself (i.e. `staking.bond` can't be subsidized, but `asset.createAsset` can)
+     * @note this depends on the type of transaction itself (e.g. `staking.bond` can't be subsidized, but `asset.createAsset` can)
      */
     abstract supportsSubsidy(): boolean;
     /**
@@ -150,18 +166,37 @@ export declare abstract class PolymeshTransactionBase<Values extends unknown[] =
      */
     protected ignoresSubsidy(): boolean;
     /**
-     * @hidden
-     *
-     * Fetch and calculate this transaction's protocol fees
+     * Return this transaction's protocol fees. These are extra fees charged for
+     *   specific operations on the chain. Not to be confused with network fees (which
+     *   depend on the complexity of the operation), protocol fees are set by governance and/or
+     *   chain upgrades
      */
-    protected abstract getProtocolFees(): Promise<BigNumber>;
+    abstract getProtocolFees(): Promise<BigNumber>;
     /**
      * @hidden
      */
-    protected handleExtrinsicFailure(_resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, reject: (reason?: unknown) => void, error: DispatchError, data?: Record<string, unknown>): void;
+    protected handleExtrinsicFailure(_resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, reject: (reason?: unknown) => void, error: SpRuntimeDispatchError, data?: Record<string, unknown>): void;
     /**
      * @hidden
      */
     protected handleExtrinsicSuccess(resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, _reject: (reason?: unknown) => void, receipt: ISubmittableResult): void;
+    /**
+     * @hidden
+     *
+     * Check if balances and allowances (both third party and signing Account)
+     *   are sufficient to cover this transaction's fees
+     */
+    private assertFeesCovered;
+    /**
+     * @hidden
+     *
+     * Retrieve the Account that would pay fees for the transaction if it was run at this moment, as well as the total amount that can be
+     *   charged to it (allowance) in case of a subsidy
+     *
+     * @note the paying Account might change if, before running the transaction, the caller Account enters (or leaves)
+     *   a subsidizer relationship. A governance vote or chain upgrade could also cause the value to change between the time
+     *   this method is called and the time the transaction is run
+     */
+    private getPayingAccount;
 }
 //# sourceMappingURL=PolymeshTransactionBase.d.ts.map

package/base/PolymeshTransactionBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PolymeshTransactionBase.d.ts","sourceRoot":"","sources":["../../src/base/PolymeshTransactionBase.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"PolymeshTransactionBase.d.ts","sourceRoot":"","sources":["../../src/base/PolymeshTransactionBase.ts"],"names":[],"mappings":"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"}

package/base/PolymeshTransactionBase.js

@@ -14,17 +14,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolymeshTransactionBase = 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("../types/internal");
 const conversion_1 = require("../utils/conversion");
-const internal_2 = require("../utils/internal");
+const internal_3 = require("../utils/internal");
 /**
  * @hidden
  */
 var Event;
 (function (Event) {
     Event["StatusChange"] = "StatusChange";
+    Event["ProcessedByMiddleware"] = "ProcessedByMiddleware";
 })(Event || (Event = {}));
 /**
  * Wrapper class for a Polymesh Transaction
@@ -41,31 +46,61 @@ class PolymeshTransactionBase {
         /**
          * @hidden
          *
-         * wrappers for values that will exist after this transaction has executed
+         * internal event emitter to handle status changes
          */
-        this.postValues = [];
-        const { postTransactionValues, signingAddress, signer, isCritical, fee, paidForBy } = transactionSpec;
-        if (postTransactionValues) {
-            this.postValues = postTransactionValues;
-        }
         this.emitter = new events_1.EventEmitter();
+        /**
+         * @hidden
+         * whether the queue has run or not (prevents re-running)
+         */
+        this.hasRun = false;
+        const { resolver, transformer, signingAddress, signer, paidForBy } = transactionSpec;
         this.signingAddress = signingAddress;
         this.signer = signer;
-        this.isCritical = isCritical;
-        this.protocolFee = fee;
         this.context = context;
         this.paidForBy = paidForBy;
+        this.transformer = transformer;
+        this.resolver = resolver;
     }
     /**
-     * Run the transaction and update its status
+     * @hidden
+     */
+    static toTransactionSpec(transaction) {
+        const { resolver, transformer, paidForBy } = transaction;
+        return {
+            resolver,
+            transformer,
+            paidForBy,
+        };
+    }
+    /**
+     * Run the transaction, update its status and return a result if applicable.
+     *   Certain transactions create Entities on the blockchain, and those Entities are returned
+     *   for convenience. For example, when running a transaction that creates an Asset, the Asset itself
+     *   is returned
      */
     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',
+                });
+            }
             try {
+                yield this.assertFeesCovered();
                 const receipt = yield this.internalRun();
                 this.receipt = receipt;
-                yield Promise.all(this.postValues.map(postValue => postValue.run(receipt)));
+                const { resolver, transformer = (val) => __awaiter(this, void 0, void 0, function* () { return val; }), } = this;
+                let value;
+                if ((0, internal_2.isResolverFunction)(resolver)) {
+                    value = yield resolver(receipt);
+                }
+                else {
+                    value = resolver;
+                }
                 this.updateStatus(types_1.TransactionStatus.Succeeded);
+                return transformer(value);
             }
             catch (err) {
                 const error = err;
@@ -88,6 +123,16 @@ class PolymeshTransactionBase {
                 }
                 throw error;
             }
+            finally {
+                this.hasRun = true;
+                /*
+                 * 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
+                 */
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this.emitWhenMiddlewareIsSynced();
+            }
         });
     }
     /**
@@ -98,14 +143,13 @@ class PolymeshTransactionBase {
      */
     internalRun() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { signingAddress, signer } = this;
+            const { signingAddress, signer, context } = this;
+            const nonce = context.getNonce().toNumber();
             this.updateStatus(types_1.TransactionStatus.Unapproved);
             return new Promise((resolve, reject) => {
                 const txWithArgs = this.composeTx();
                 let settingBlockData = Promise.resolve();
-                // nonce: -1 takes pending transactions into consideration.
-                // More information can be found at: https://polkadot.js.org/docs/api/cookbook/tx/#how-do-i-take-the-pending-tx-pool-into-account-in-my-nonce
-                const gettingUnsub = txWithArgs.signAndSend(signingAddress, { nonce: -1, signer }, receipt => {
+                const gettingUnsub = txWithArgs.signAndSend(signingAddress, { nonce, signer }, receipt => {
                     const { status } = receipt;
                     let isLastCallback = false;
                     let unsubscribing = Promise.resolve();
@@ -119,7 +163,7 @@ class PolymeshTransactionBase {
                              *   is emitted, and at the same time. We do not resolve or reject the containing promise until this
                              *   one resolves
                              */
-                            settingBlockData = (0, internal_2.defusePromise)(this.context.polymeshApi.rpc.chain.getBlock(blockHash).then(({ block }) => {
+                            settingBlockData = (0, internal_3.defusePromise)(this.context.polymeshApi.rpc.chain.getBlock(blockHash).then(({ block }) => {
                                 this.blockHash = (0, conversion_1.hashToString)(blockHash);
                                 this.blockNumber = (0, conversion_1.u32ToBigNumber)(block.header.number.unwrap());
                                 // we know that the index has to be set by the time the transaction is included in a block
@@ -127,7 +171,7 @@ class PolymeshTransactionBase {
                                 this.txIndex = new bignumber_js_1.default(receipt.txIndex);
                             }));
                             // if the extrinsic failed due to an on-chain error, we should handle it in a special way
-                            extrinsicFailedEvent = receipt.findRecord('system', 'ExtrinsicFailed');
+                            [extrinsicFailedEvent] = (0, internal_3.filterEventRecords)(receipt, 'system', 'ExtrinsicFailed', true);
                             // extrinsic failed so we can unsubscribe
                             isLastCallback = !!extrinsicFailedEvent;
                         }
@@ -146,7 +190,7 @@ class PolymeshTransactionBase {
                          */
                         let finishing = Promise.resolve();
                         if (extrinsicFailedEvent) {
-                            const { event: { data }, } = extrinsicFailedEvent;
+                            const { data } = extrinsicFailedEvent;
                             finishing = Promise.all([settingBlockData, unsubscribing]).then(() => {
                                 this.handleExtrinsicFailure(resolve, reject, data[0]);
                             });
@@ -192,96 +236,139 @@ class PolymeshTransactionBase {
      * @returns unsubscribe function
      */
     onStatusChange(listener) {
-        this.emitter.on(Event.StatusChange, listener);
+        const { emitter } = this;
+        emitter.on(Event.StatusChange, listener);
         return () => {
-            this.emitter.removeListener(Event.StatusChange, listener);
+            emitter.removeListener(Event.StatusChange, listener);
         };
     }
     /**
-     * Retrieve the Account that would pay fees for the transaction if it was run at this moment, as well as the total amount that can be
-     *   charged to it (allowance). A null allowance means that there is no limit to that amount
-     *
-     * A null return value signifies that the caller Account would pay the fees
+     * Retrieve a breakdown of the fees required to run this transaction, as well as the Account responsible for paying them
      *
-     * @note this value might change if, before running the transaction, the caller Account enters (or leaves)
-     *   a subsidizer relationship
+     * @note these values might be inaccurate if the transaction is run at a later time. This can be due to a governance vote or other
+     *   chain related factors (like modifications to a specific subsidizer relationship or a chain upgrade)
      */
-    getPayingAccount() {
+    getTotalFees() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { paidForBy, context } = this;
-            if (this.ignoresSubsidy()) {
-                return null;
-            }
-            if (paidForBy) {
-                const { account: primaryAccount } = yield paidForBy.getPrimaryAccount();
-                return {
-                    type: types_1.PayingAccountType.Other,
-                    account: primaryAccount,
-                    allowance: null,
-                };
-            }
-            const subsidyWithAllowance = yield context.accountSubsidy();
-            if (!subsidyWithAllowance) {
-                return null;
-            }
-            const { subsidy: { subsidizer: account }, allowance, } = subsidyWithAllowance;
+            const { signingAddress } = this;
+            const composedTx = this.composeTx();
+            const paymentInfoPromise = composedTx.paymentInfo(signingAddress);
+            const protocol = yield this.getProtocolFees();
+            const [payingAccount, { partialFee }] = yield Promise.all([
+                this.getPayingAccount(),
+                paymentInfoPromise,
+            ]);
+            const { free: balance } = yield payingAccount.account.getBalance();
+            const gas = (0, conversion_1.balanceToBigNumber)(partialFee);
             return {
-                type: types_1.PayingAccountType.Subsidy,
-                account,
-                allowance,
+                fees: {
+                    protocol,
+                    gas,
+                    total: protocol.plus(gas),
+                },
+                payingAccountData: Object.assign(Object.assign({}, payingAccount), { balance }),
             };
         });
     }
     /**
-     * Get all (protocol and gas) fees associated with this transaction. Returns null
-     * if the transaction is not ready yet (this can happen if it depends on the execution of a
-     * previous transaction in the queue)
+     * Subscribe to the results of this transaction being processed by the indexing service (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) {
+        const { context, emitter } = this;
+        if (!context.isMiddlewareEnabled()) {
+            throw new internal_1.PolymeshError({
+                code: types_1.ErrorCode.General,
+                message: 'Cannot subscribe without an enabled middleware connection',
+            });
+        }
+        emitter.on(Event.ProcessedByMiddleware, listener);
+        return () => {
+            emitter.removeListener(Event.ProcessedByMiddleware, listener);
+        };
+    }
+    /**
+     * Poll the middleware every 2 seconds to see if it has already processed the
+     *   block that reflects the changes brought on by this transaction 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 this value might change if the transaction is run at a later time. This can be due to a governance vote
+     * @note uses the middleware
      */
-    getFees() {
+    emitWhenMiddlewareIsSynced() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { signingAddress } = this;
-            let { protocolFee: protocol } = this;
-            let composedTx;
+            const { context, emitter } = this;
             try {
-                composedTx = this.composeTx();
+                if (!context.isMiddlewareEnabled()) {
+                    return;
+                }
+                const blockNumber = yield context.getLatestBlock();
+                let done = false;
+                yield 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;
+                            emitter.emit(Event.ProcessedByMiddleware);
+                            return;
+                        }
+                    }
+                    catch (err) {
+                        /*
+                         * query errors are swallowed because we wish to query again if we haven't reached the
+                         * maximum amount of retries
+                         */
+                    }
+                    if (i === 5) {
+                        emitter.emit(Event.ProcessedByMiddleware, new internal_1.PolymeshError({
+                            code: types_1.ErrorCode.MiddlewareError,
+                            message: `Middleware has not synced after ${i} attempts`,
+                        }));
+                    }
+                    return (0, internal_3.delay)(2000);
+                }));
             }
             catch (err) {
-                return null;
+                /* istanbul ignore next: extreme edge case */
+                emitter.emit(Event.ProcessedByMiddleware, new internal_1.PolymeshError({
+                    code: types_1.ErrorCode.UnexpectedError,
+                    message: err.message || 'Unexpected error',
+                }));
             }
-            const paymentInfoPromise = composedTx.paymentInfo(signingAddress);
-            if (!protocol) {
-                protocol = yield this.getProtocolFees();
-            }
-            const { partialFee } = yield paymentInfoPromise;
-            return {
-                protocol,
-                gas: (0, conversion_1.balanceToBigNumber)(partialFee),
-            };
         });
     }
     /**
      * @hidden
      */
     updateStatus(status) {
+        const { emitter } = this;
         this.status = status;
         /* eslint-disable default-case */
         switch (status) {
             case types_1.TransactionStatus.Unapproved:
             case types_1.TransactionStatus.Running:
             case types_1.TransactionStatus.Succeeded: {
-                this.emitter.emit(Event.StatusChange, this);
+                emitter.emit(Event.StatusChange, this);
                 return;
             }
             case types_1.TransactionStatus.Rejected:
             case types_1.TransactionStatus.Aborted:
             case types_1.TransactionStatus.Failed: {
-                this.emitter.emit(Event.StatusChange, this, this.error);
+                emitter.emit(Event.StatusChange, this, this.error);
             }
         }
         /* eslint-enable default-case */
     }
+    /* istanbul ignore next: there is no way of reaching this path currently */
     /**
      * @hidden
      *
@@ -324,6 +411,88 @@ class PolymeshTransactionBase {
     handleExtrinsicSuccess(resolve, _reject, receipt) {
         resolve(receipt);
     }
+    /**
+     * @hidden
+     *
+     * Check if balances and allowances (both third party and signing Account)
+     *   are sufficient to cover this transaction's fees
+     */
+    assertFeesCovered() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fees: { total }, payingAccountData, } = yield this.getTotalFees();
+            const { type, balance } = payingAccountData;
+            if (type === types_1.PayingAccountType.Subsidy) {
+                const { allowance } = payingAccountData;
+                if (!this.supportsSubsidy()) {
+                    throw new internal_1.PolymeshError({
+                        code: types_1.ErrorCode.UnmetPrerequisite,
+                        message: 'This transaction cannot be run by a subsidized Account',
+                    });
+                }
+                if (allowance.lt(total)) {
+                    throw new internal_1.PolymeshError({
+                        code: types_1.ErrorCode.UnmetPrerequisite,
+                        message: "Insufficient subsidy allowance to pay this transaction's fees",
+                        data: {
+                            allowance,
+                            fees: total,
+                        },
+                    });
+                }
+            }
+            const accountDescriptions = {
+                [types_1.PayingAccountType.Caller]: 'caller',
+                [types_1.PayingAccountType.Other]: 'paying third party',
+                [types_1.PayingAccountType.Subsidy]: 'subsidizer',
+            };
+            if (balance.lt(total)) {
+                throw new internal_1.PolymeshError({
+                    code: types_1.ErrorCode.InsufficientBalance,
+                    message: `The ${accountDescriptions[type]} Account does not have enough POLYX balance to pay this transaction's fees`,
+                    data: {
+                        balance,
+                        fees: total,
+                    },
+                });
+            }
+        });
+    }
+    /**
+     * @hidden
+     *
+     * Retrieve the Account that would pay fees for the transaction if it was run at this moment, as well as the total amount that can be
+     *   charged to it (allowance) in case of a subsidy
+     *
+     * @note the paying Account might change if, before running the transaction, the caller Account enters (or leaves)
+     *   a subsidizer relationship. A governance vote or chain upgrade could also cause the value to change between the time
+     *   this method is called and the time the transaction is run
+     */
+    getPayingAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { paidForBy, context } = this;
+            if (paidForBy) {
+                const { account: primaryAccount } = yield paidForBy.getPrimaryAccount();
+                return {
+                    type: types_1.PayingAccountType.Other,
+                    account: primaryAccount,
+                };
+            }
+            const subsidyWithAllowance = yield context.accountSubsidy();
+            if (!subsidyWithAllowance || this.ignoresSubsidy()) {
+                const caller = context.getSigningAccount();
+                return {
+                    account: caller,
+                    type: types_1.PayingAccountType.Caller,
+                };
+            }
+            const { subsidy: { subsidizer: account }, allowance, } = subsidyWithAllowance;
+            return {
+                type: types_1.PayingAccountType.Subsidy,
+                account,
+                allowance,
+            };
+        });
+    }
 }
 exports.PolymeshTransactionBase = PolymeshTransactionBase;
 //# sourceMappingURL=PolymeshTransactionBase.js.map