@stellar-expert/tx-meta-effects-parser 5.2.0 → 5.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar-expert/tx-meta-effects-parser",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "description": "Low-level effects parser for Stellar transaction results and meta XDR",
   "main": "src/index.js",
   "scripts": {

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,23 +99,37 @@ 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/71170fba76e1aa4d50224316f1157f0fb10e6d79/soroban-sdk/src/token.rs
+            //see https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/src/token.rs
             case 'transfer': {
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     return
@@ -212,6 +226,19 @@ class EventsAnalyzer {
                 }
             }
                 break
+            case 'set_admin': {
+                if (!matchEventTopicsShape(topics, ['address', 'str?']))
+                    return //throw new Error('Non-standard event')
+                const currentAdmin = xdrParseScVal(topics[1])
+                const newAdmin = processEventBodyValue(body.data())
+                if (!this.matchInvocationEffect(e => e.function === 'set_admin' && matchArrays([currentAdmin, newAdmin], [this.effectsAnalyzer.source, e.args])))
+                    return
+                this.effectsAnalyzer.setAdmin(contractId, newAdmin)
+                if (topics.length > 2) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[2])))
+                }
+            }
+                break
             /*case 'approve': { //TODO: think about processing this effect
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     throw new Error('Non-standard event')

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)
@@ -375,6 +399,15 @@ class EffectsAnalyzer {
     restoreFootprint() {
     }
 
+    setAdmin(contractId, newAdmin) {
+        const effect = {
+            type: effectTypes.contractUpdated,
+            contract: contractId,
+            admin: newAdmin
+        }
+        this.addEffect(effect)
+    }
+
     processDexOperationEffects() {
         //process trades first
         for (const claimedOffer of this.result.claimedOffers) {

package/src/index.js

@@ -17,9 +17,10 @@ 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
  * @return {ParsedTxOperationsMetadata}
  */
-function parseTxOperationsMeta({network, tx, result, meta, mapSac = false}) {
+function parseTxOperationsMeta({network, tx, result, meta, mapSac = false, processSystemEvents = false}) {
     if (!network)
         throw new TypeError(`Network passphrase argument is required.`)
     if (typeof network !== 'string')
@@ -138,6 +139,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()