@stellar-expert/tx-meta-effects-parser 5.3.0 → 5.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar-expert/tx-meta-effects-parser",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "description": "Low-level effects parser for Stellar transaction results and meta XDR",
   "main": "src/index.js",
   "scripts": {
@@ -9,7 +9,7 @@
   "author": "team@stellar.expert",
   "license": "MIT",
   "peerDependencies": {
-    "@stellar/stellar-base": "^11.0.0"
+    "@stellar/stellar-base": "^12.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.22.9",

package/src/aggregation/events-analyzer.js

@@ -61,13 +61,13 @@ class EventsAnalyzer {
      * @private
      */
     analyzeDiagnosticEvents() {
-        const {diagnosticEvents} = this.effectsAnalyzer
+        const {diagnosticEvents, processSystemEvents} = this.effectsAnalyzer
         if (!diagnosticEvents)
             return
         //diagnostic events
         for (const evt of diagnosticEvents) {
-            if (!evt.inSuccessfulContractCall())
-                return //throw new UnexpectedTxMetaChangeError({type: 'diagnostic_event', action: 'failed'})
+            if (!processSystemEvents && !evt.inSuccessfulContractCall())
+                continue //throw new UnexpectedTxMetaChangeError({type: 'diagnostic_event', action: 'failed'})
             //parse event
             const event = evt.event()
             const contractId = event.contractId()
@@ -90,7 +90,7 @@ class EventsAnalyzer {
                 if (type !== EVENT_TYPES.DIAGNOSTIC)
                     return // skip non-diagnostic events
                 const rawArgs = body.data()
-                const parsedEvent = {
+                const funcCall = {
                     type: effectTypes.contractInvoked,
                     contract: xdrParseScVal(topics[1], true),
                     function: xdrParseScVal(topics[2]),
@@ -99,21 +99,35 @@ class EventsAnalyzer {
                 }
                 //add the invocation to the call stack
                 if (this.callStack.length) {
-                    parsedEvent.depth = this.callStack.length
+                    funcCall.depth = this.callStack.length
                 }
-                this.callStack.push(parsedEvent)
-                this.effectsAnalyzer.addEffect(parsedEvent)
+                this.callStack.push(funcCall)
+                this.effectsAnalyzer.addEffect(funcCall)
                 break
             case 'fn_return':
                 if (type !== EVENT_TYPES.DIAGNOSTIC)
                     return // skip non-diagnostic events
                 //attach execution result to the contract invocation event
-                const funcCall = this.callStack.pop()
+                const lastFuncCall = this.callStack.pop()
                 const result = body.data()
                 if (result.switch().name !== 'scvVoid') {
-                    funcCall.result = result.toXDR('base64')
+                    lastFuncCall.result = result.toXDR('base64')
                 }
                 break
+            case 'error':
+                if (type !== EVENT_TYPES.DIAGNOSTIC)
+                    return // skip non-diagnostic events
+                this.effectsAnalyzer.addEffect({
+                    type: effectTypes.contractError,
+                    code: topics[1].value().value(),
+                    details: processEventBodyValue(body.data())
+                })
+                break
+            case 'core_metrics':
+                if (type !== EVENT_TYPES.DIAGNOSTIC)
+                    return // skip non-diagnostic events
+                this.effectsAnalyzer.addMetric(xdrParseScVal(topics[1]), parseInt(processEventBodyValue(body.data())))
+                break
             //handle standard token contract events
             //see https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/src/token.rs
             case 'transfer': {

package/src/effect-types.js

@@ -86,12 +86,14 @@ const effectTypes = {
     contractUpdated: 'contractUpdated',
 
     contractInvoked: 'contractInvoked',
+    contractError: 'contractError',
 
     contractDataCreated: 'contractDataCreated',
     contractDataUpdated: 'contractDataUpdated',
     contractDataRemoved: 'contractDataRemoved',
 
-    contractEvent: 'contractEvent'
+    contractEvent: 'contractEvent',
+    contractMetrics: 'contractMetrics'
 }
 
 module.exports = effectTypes

package/src/effects-analyzer.js

@@ -9,7 +9,7 @@ const AssetSupplyAnalyzer = require('./aggregation/asset-supply-analyzer')
 const {UnexpectedTxMetaChangeError, TxMetaEffectParserError} = require('./errors')
 
 class EffectsAnalyzer {
-    constructor({operation, meta, result, network, events, diagnosticEvents, mapSac}) {
+    constructor({operation, meta, result, network, events, diagnosticEvents, mapSac, processSystemEvents}) {
         //set execution context
         if (!operation.source)
             throw new TxMetaEffectParserError('Operation source is not explicitly defined')
@@ -21,6 +21,9 @@ class EffectsAnalyzer {
         this.events = events
         if (diagnosticEvents?.length) {
             this.diagnosticEvents = diagnosticEvents
+            if (processSystemEvents) {
+                this.processSystemEvents = true
+            }
         }
         this.network = network
         if (mapSac) {
@@ -69,10 +72,20 @@ class EffectsAnalyzer {
      */
     source = ''
     /**
-     * @type {boolean}
+     * @type {Boolean}
      * @private
      */
     isContractCall = false
+    /**
+     * @type {Boolean}
+     * @readonly
+     */
+    processSystemEvents = false
+    /**
+     * @type {{}}
+     * @private
+     */
+    metrics
 
     analyze() {
         //find appropriate parser method
@@ -160,6 +173,17 @@ class EffectsAnalyzer {
         }, position)
     }
 
+    addMetric(metric, value) {
+        let {metrics} = this
+        if (!metrics) {
+            metrics = this.metrics = {
+                type: effectTypes.contractMetrics
+            }
+            this.addEffect(metrics)
+        }
+        metrics[metric] = value
+    }
+
     setOptions() {
         const sourceAccount = normalizeAddress(this.source)
         const {before, after} = this.changes.find(ch => ch.type === 'account' && ch.before.address === sourceAccount)

package/src/index.js

@@ -17,9 +17,11 @@ const effectTypes = require('./effect-types')
  * @param {String|Buffer|xdr.TransactionResult} [result] - Base64-encoded tx envelope result
  * @param {String|Buffer|xdr.TransactionMeta} [meta] - Base64-encoded tx envelope meta
  * @param {Boolean} [mapSac] - Whether to create a map SAC->Asset
+ * @param {Boolean} [processSystemEvents] - Emit effects for contract errors and resource stats
+ * @param {Number} [protocol] - Specific Stellar protocol version for the executed transaction
  * @return {ParsedTxOperationsMetadata}
  */
-function parseTxOperationsMeta({network, tx, result, meta, mapSac = false}) {
+function parseTxOperationsMeta({network, tx, result, meta, mapSac = false, processSystemEvents = false, protocol}) {
     if (!network)
         throw new TypeError(`Network passphrase argument is required.`)
     if (typeof network !== 'string')
@@ -112,7 +114,7 @@ function parseTxOperationsMeta({network, tx, result, meta, mapSac = false}) {
             effect.source = (before || after).address
             res.effects.push(effect)
         }
-        if (isFeeBump && before.balance !== after.balance) { //fee bump fee calculation bug
+        if (isFeeBump && protocol === 20 && before.balance !== after.balance) { //bump fee calculation bug in protocol v20
             const currentFee = BigInt(feeEffect.charged)
             const diff = BigInt(after.balance) - BigInt(before.balance)
             if (diff < currentFee) { // do not allow negative fee
@@ -138,6 +140,7 @@ function parseTxOperationsMeta({network, tx, result, meta, mapSac = false}) {
                 params.events = sorobanMeta.events()
                 params.diagnosticEvents = sorobanMeta.diagnosticEvents()
                 params.mapSac = mapSac
+                params.processSystemEvents = processSystemEvents
             }
             const analyzer = new EffectsAnalyzer(params)
             operation.effects = analyzer.analyze()