@polymeshassociation/polymesh-sdk 16.0.0-alpha.1 → 16.0.0-beta.1

package/base/PolymeshTransactionBase.d.ts

@@ -1,20 +1,16 @@
 /// <reference types="node" />
 import { SubmittableExtrinsic } from '@polkadot/api/types';
-import { SpRuntimeDispatchError } from "../polkadot/types-lookup.ts";
+import { DispatchError } from '@polkadot/types/interfaces';
 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 { GenericPolymeshTransaction, PayingAccountFees, TransactionStatus, UnsubCallback } from "../types";
-import { BaseTransactionSpec, MaybeResolverFunction, TransactionSigningData } from "../types/internal";
+import { Fees, PayingAccount, TransactionStatus } from "../types";
+import { BaseTransactionSpec, PostTransactionValueArray } from "../types/internal";
 /**
  * Wrapper class for a Polymesh Transaction
  */
-export declare abstract class PolymeshTransactionBase<ReturnValue = void, TransformedReturnValue = ReturnValue> {
-    /**
-     * @hidden
-     */
-    static toTransactionSpec<R, T>(transaction: PolymeshTransactionBase<R, T>): BaseTransactionSpec<R, T>;
+export declare abstract class PolymeshTransactionBase<Values extends unknown[] = unknown[]> {
     /**
      * current status of the transaction
      */
@@ -43,6 +39,10 @@ export declare abstract class PolymeshTransactionBase<ReturnValue = void, Transf
      * 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<ReturnValue = void, Transf
     /**
      * @hidden
      *
-     * function that transforms the transaction's return value before returning it after it is run
+     * wrappers for values that will exist after this transaction has executed
      */
-    protected resolver: MaybeResolverFunction<ReturnValue>;
+    protected postValues: PostTransactionValueArray<Values>;
     /**
      * @hidden
      *
@@ -77,27 +77,20 @@ export declare abstract class PolymeshTransactionBase<ReturnValue = void, Transf
     /**
      * @hidden
      *
-     * 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
+     * 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
      */
-    protected transformer?: (result: ReturnValue) => Promise<TransformedReturnValue> | TransformedReturnValue;
+    protected protocolFee?: BigNumber;
     protected context: Context;
     /**
      * @hidden
-     * whether the queue has run or not (prevents re-running)
      */
-    private hasRun;
+    constructor(transactionSpec: BaseTransactionSpec<Values>, context: Context);
     /**
-     * @hidden
+     * Run the transaction and update its status
      */
-    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>;
+    run(): Promise<void>;
     /**
      * @hidden
      *
@@ -112,34 +105,25 @@ export declare abstract class PolymeshTransactionBase<ReturnValue = void, Transf
      *
      * @returns unsubscribe function
      */
-    onStatusChange(listener: (transaction: GenericPolymeshTransaction<ReturnValue, TransformedReturnValue>) => void): UnsubCallback;
-    /**
-     * 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>;
+    onStatusChange(listener: (transaction: this) => void): () => void;
     /**
-     * Subscribe to the results of this transaction being processed by the indexing service (and as such, available to the middleware)
+     * 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
      *
-     * @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
+     * A null return value signifies that the caller Account would pay the fees
      *
-     * @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
+     * @note this value might change if, before running the transaction, the caller Account enters (or leaves)
+     *   a subsidizer relationship
      */
-    onProcessedByMiddleware(listener: (err?: PolymeshError) => void): UnsubCallback;
+    getPayingAccount(): Promise<PayingAccount | null>;
     /**
-     * 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
+     * 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)
      *
-     * @note uses the middleware
+     * @note this value might change if the transaction is run at a later time. This can be due to a governance vote
      */
-    private emitWhenMiddlewareIsSynced;
+    getFees(): Promise<Fees | null>;
     /**
      * @hidden
      */
@@ -149,7 +133,7 @@ export declare abstract class PolymeshTransactionBase<ReturnValue = void, Transf
      *   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 (e.g. `staking.bond` can't be subsidized, but `asset.createAsset` can)
+     * @note this depends on the type of transaction itself (i.e. `staking.bond` can't be subsidized, but `asset.createAsset` can)
      */
     abstract supportsSubsidy(): boolean;
     /**
@@ -165,38 +149,19 @@ export declare abstract class PolymeshTransactionBase<ReturnValue = void, Transf
      *   and is always paid by the caller
      */
     protected ignoresSubsidy(): boolean;
-    /**
-     * 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
-     */
-    abstract getProtocolFees(): Promise<BigNumber>;
-    /**
-     * @hidden
-     */
-    protected handleExtrinsicFailure(_resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, reject: (reason?: unknown) => void, error: SpRuntimeDispatchError, data?: Record<string, unknown>): void;
     /**
      * @hidden
+     *
+     * Fetch and calculate this transaction's protocol fees
      */
-    protected handleExtrinsicSuccess(resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, _reject: (reason?: unknown) => void, receipt: ISubmittableResult): void;
+    protected abstract getProtocolFees(): Promise<BigNumber>;
     /**
      * @hidden
-     *
-     * Check if balances and allowances (both third party and signing Account)
-     *   are sufficient to cover this transaction's fees
      */
-    private assertFeesCovered;
+    protected handleExtrinsicFailure(_resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, reject: (reason?: unknown) => void, error: DispatchError, data?: Record<string, unknown>): void;
     /**
      * @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;
+    protected handleExtrinsicSuccess(resolve: (value: ISubmittableResult | PromiseLike<ISubmittableResult>) => void, _reject: (reason?: unknown) => void, receipt: ISubmittableResult): void;
 }
 //# 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,22 +14,17 @@ 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_3 = require("../utils/internal");
+const internal_2 = require("../utils/internal");
 /**
  * @hidden
  */
 var Event;
 (function (Event) {
     Event["StatusChange"] = "StatusChange";
-    Event["ProcessedByMiddleware"] = "ProcessedByMiddleware";
 })(Event || (Event = {}));
 /**
  * Wrapper class for a Polymesh Transaction
@@ -46,61 +41,31 @@ class PolymeshTransactionBase {
         /**
          * @hidden
          *
-         * internal event emitter to handle status changes
+         * wrappers for values that will exist after this transaction has executed
          */
+        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;
     }
     /**
-     * @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 the transaction and update its status
      */
     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;
-                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;
-                }
+                yield Promise.all(this.postValues.map(postValue => postValue.run(receipt)));
                 this.updateStatus(types_1.TransactionStatus.Succeeded);
-                return transformer(value);
             }
             catch (err) {
                 const error = err;
@@ -123,16 +88,6 @@ 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();
-            }
         });
     }
     /**
@@ -143,13 +98,14 @@ class PolymeshTransactionBase {
      */
     internalRun() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { signingAddress, signer, context } = this;
-            const nonce = context.getNonce().toNumber();
+            const { signingAddress, signer } = this;
             this.updateStatus(types_1.TransactionStatus.Unapproved);
             return new Promise((resolve, reject) => {
                 const txWithArgs = this.composeTx();
                 let settingBlockData = Promise.resolve();
-                const gettingUnsub = txWithArgs.signAndSend(signingAddress, { nonce, signer }, receipt => {
+                // 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 { status } = receipt;
                     let isLastCallback = false;
                     let unsubscribing = Promise.resolve();
@@ -163,7 +119,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_3.defusePromise)(this.context.polymeshApi.rpc.chain.getBlock(blockHash).then(({ block }) => {
+                            settingBlockData = (0, internal_2.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
@@ -171,7 +127,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] = (0, internal_3.filterEventRecords)(receipt, 'system', 'ExtrinsicFailed', true);
+                            extrinsicFailedEvent = receipt.findRecord('system', 'ExtrinsicFailed');
                             // extrinsic failed so we can unsubscribe
                             isLastCallback = !!extrinsicFailedEvent;
                         }
@@ -190,7 +146,7 @@ class PolymeshTransactionBase {
                          */
                         let finishing = Promise.resolve();
                         if (extrinsicFailedEvent) {
-                            const { data } = extrinsicFailedEvent;
+                            const { event: { data }, } = extrinsicFailedEvent;
                             finishing = Promise.all([settingBlockData, unsubscribing]).then(() => {
                                 this.handleExtrinsicFailure(resolve, reject, data[0]);
                             });
@@ -236,139 +192,96 @@ class PolymeshTransactionBase {
      * @returns unsubscribe function
      */
     onStatusChange(listener) {
-        const { emitter } = this;
-        emitter.on(Event.StatusChange, listener);
+        this.emitter.on(Event.StatusChange, listener);
         return () => {
-            emitter.removeListener(Event.StatusChange, listener);
+            this.emitter.removeListener(Event.StatusChange, listener);
         };
     }
     /**
-     * Retrieve a breakdown of the fees required to run this transaction, as well as the Account responsible for paying them
+     * 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
      *
-     * @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)
+     * @note this value might change if, before running the transaction, the caller Account enters (or leaves)
+     *   a subsidizer relationship
      */
-    getTotalFees() {
+    getPayingAccount() {
         return __awaiter(this, void 0, void 0, function* () {
-            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);
+            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;
             return {
-                fees: {
-                    protocol,
-                    gas,
-                    total: protocol.plus(gas),
-                },
-                payingAccountData: Object.assign(Object.assign({}, payingAccount), { balance }),
+                type: types_1.PayingAccountType.Subsidy,
+                account,
+                allowance,
             };
         });
     }
     /**
-     * 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
+     * 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)
      *
-     * @note uses the middleware
+     * @note this value might change if the transaction is run at a later time. This can be due to a governance vote
      */
-    emitWhenMiddlewareIsSynced() {
+    getFees() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { context, emitter } = this;
+            const { signingAddress } = this;
+            let { protocolFee: protocol } = this;
+            let composedTx;
             try {
-                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);
-                }));
+                composedTx = this.composeTx();
             }
             catch (err) {
-                /* istanbul ignore next: extreme edge case */
-                emitter.emit(Event.ProcessedByMiddleware, new internal_1.PolymeshError({
-                    code: types_1.ErrorCode.UnexpectedError,
-                    message: err.message || 'Unexpected error',
-                }));
+                return null;
             }
+            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: {
-                emitter.emit(Event.StatusChange, this);
+                this.emitter.emit(Event.StatusChange, this);
                 return;
             }
             case types_1.TransactionStatus.Rejected:
             case types_1.TransactionStatus.Aborted:
             case types_1.TransactionStatus.Failed: {
-                emitter.emit(Event.StatusChange, this, this.error);
+                this.emitter.emit(Event.StatusChange, this, this.error);
             }
         }
         /* eslint-enable default-case */
     }
-    /* istanbul ignore next: there is no way of reaching this path currently */
     /**
      * @hidden
      *
@@ -411,88 +324,6 @@ 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