TransactionQueue
Class to manage procedural transaction queues

Type parameters

ProcedureReturnType
ReturnType
TransactionArgs: unknown[][]

Hierarchy

    TransactionQueue

Index

Constructors

Properties

Methods

Constructors

constructor

+ new TransactionQueue(args: object, context: Context): TransactionQueue
Create a transaction queue
Parameters:
args: object
Name
Type
Description
procedureResult
MaybePostTransactionValue‹ProcedureReturnType›
value that will be returned by the queue after it is run. It can be a [[PostTransactionValue]]
transactions
PolymeshTransactionArray‹TransactionArgs›
list of transactions to be run in this queue
transformer?
undefined | function
function that transforms the procedure's return value before returning it after the queue is run
context: Context
Returns: TransactionQueue

Properties

Optional error

error? : PolymeshError
optional error information

status

status: TransactionQueueStatus = TransactionQueueStatus.Idle
status of the queue

transactions

transactions: PolymeshTransactionArray‹TransactionArgs›
transactions that will be run in the queue

Methods

getMinFees

getMinFees(): Promise‹FeesBreakdown
Retrieves 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 current Account and those that will be paid by third parties. In most cases, the entirety of the fees will be paid by either the current Account or a single third party Account
Returns: Promise‹FeesBreakdown

onProcessedByMiddleware

onProcessedByMiddleware(listener: function): function
Subscribe to the results of this queue being processed by the harvester (and as such, available to the middleware)
note this event will be fired even if the queue fails
throws if the middleware wasn't enabled when instantiating the SDK client
Parameters:
listener: function
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
▸ (err?: PolymeshError): void
Parameters:
Name
Type
err?
Returns: function
unsubscribe function
▸ (): void

onStatusChange

onStatusChange(listener: function): function
Subscribe to status changes on the Transaction Queue
Parameters:
listener: function
callback function that will be called whenever the Transaction Queue's status changes
▸ (transactionQueue: this, err?: PolymeshError): void
Parameters:
Name
Type
transactionQueue
this
err?
Returns: function
unsubscribe function
▸ (): void

onTransactionStatusChange

onTransactionStatusChangeTxArgs, Values›(listener: function): function
Subscribe to status changes on individual transactions
Type parameters:
TxArgs: unknown[]
Values: unknown[]
Parameters:
listener: function
callback function that will be called whenever the individual transaction's status changes
▸ (transaction: PolymeshTransactionBase‹TxArgs, Values›, transactionQueue: this): void
Parameters:
Name
Type
transaction
PolymeshTransactionBase‹TxArgs, Values›
transactionQueue
this
Returns: function
unsubscribe function
▸ (): void

run

run(): Promise‹ReturnType›
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
Returns: Promise‹ReturnType›
Last modified 26d ago