@stellar-expert/tx-meta-effects-parser 6.0.3 → 6.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar-expert/tx-meta-effects-parser",
-  "version": "6.0.3",
+  "version": "6.1.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": "^12.1.0"
+    "@stellar/stellar-base": "^12.1.1"
   },
   "devDependencies": {
     "@babel/core": "^7.22.9",

package/src/aggregation/events-analyzer.js

@@ -61,13 +61,13 @@ class EventsAnalyzer {
      * @private
      */
     analyzeDiagnosticEvents() {
-        const {diagnosticEvents, processSystemEvents} = this.effectsAnalyzer
+        const {diagnosticEvents, processSystemEvents, processMetrics, processFailedOpEffects} = this.effectsAnalyzer
         if (!diagnosticEvents)
             return
         const opContractId = this.effectsAnalyzer.retrieveOpContractId()
         //diagnostic events
         for (const evt of diagnosticEvents) {
-            if (!processSystemEvents && !(evt.inSuccessfulContractCall() || this.effectsAnalyzer.processFailedOpEffects))
+            if (!processSystemEvents && !(processFailedOpEffects || evt.inSuccessfulContractCall()))
                 continue //throw new UnexpectedTxMetaChangeError({type: 'diagnostic_event', action: 'failed'})
             //parse event
             const event = evt.event()
@@ -75,7 +75,7 @@ class EventsAnalyzer {
             if (contractId && typeof contractId !== 'string') {
                 contractId = StrKey.encodeContract(contractId)
             }
-            this.processDiagnosticEvent(event.body().value(), event.type().value, contractId)
+            this.processDiagnosticEvent(event._attributes.body._value, event._attributes.type.value, contractId, processMetrics)
         }
     }
 
@@ -83,9 +83,10 @@ class EventsAnalyzer {
      * @param {xdr.ContractEventV0} body
      * @param {Number} type
      * @param {String} contract
+     * @param {Boolean} processMetrics
      * @private
      */
-    processDiagnosticEvent(body, type, contract) {
+    processDiagnosticEvent(body, type, contract, processMetrics) {
         const topics = body.topics()
         if (!topics?.length)
             return
@@ -121,16 +122,22 @@ class EventsAnalyzer {
             case 'error':
                 if (type !== EVENT_TYPES.DIAGNOSTIC)
                     return // skip non-diagnostic events
+                let code = topics[1].value().value()
+                if (code.name) {
+                    code = code.name
+                }
                 this.effectsAnalyzer.addEffect({
                     type: effectTypes.contractError,
                     contract,
-                    code: topics[1].value().value(),
+                    code,
                     details: processEventBodyValue(body.data())
                 })
                 break
             case 'core_metrics':
                 if (type !== EVENT_TYPES.DIAGNOSTIC)
                     return // skip non-diagnostic events
+                if (!processMetrics)
+                    return
                 this.effectsAnalyzer.addMetric(contract, xdrParseScVal(topics[1]), parseInt(processEventBodyValue(body.data())))
                 break
             //handle standard token contract events

package/src/effects-analyzer.js

@@ -11,7 +11,18 @@ const {UnexpectedTxMetaChangeError, TxMetaEffectParserError} = require('./errors
 const {generateContractCodeEntryHash} = require('./parser/ledger-key')
 
 class EffectsAnalyzer {
-    constructor({operation, meta, result, network, events, diagnosticEvents, mapSac, processSystemEvents, processFailedOpEffects}) {
+    constructor({
+                    operation,
+                    meta,
+                    result,
+                    network,
+                    events,
+                    diagnosticEvents,
+                    mapSac,
+                    processSystemEvents,
+                    processFailedOpEffects,
+                    processMetrics
+                }) {
         //set execution context
         if (!operation.source)
             throw new TxMetaEffectParserError('Operation source is not explicitly defined')
@@ -22,6 +33,7 @@ class EffectsAnalyzer {
         this.source = this.operation.source
         this.events = events
         this.processFailedOpEffects = processFailedOpEffects
+        this.processMetrics = processMetrics
         if (diagnosticEvents?.length) {
             this.diagnosticEvents = diagnosticEvents
             if (processSystemEvents) {
@@ -84,6 +96,11 @@ class EffectsAnalyzer {
      * @readonly
      */
     processSystemEvents = false
+    /**
+     * @type {Boolean}
+     * @readonly
+     */
+    processMetrics = true
     /**
      * @type {{}}
      * @private
@@ -106,6 +123,10 @@ class EffectsAnalyzer {
         this.processSponsorshipEffects()
         //calculate minted/burned assets
         new AssetSupplyAnalyzer(this).analyze()
+        //add Soroban op metrics if available
+        if (this.metrics) {
+            this.addEffect(this.metrics)
+        }
         return this.effects
     }
 
@@ -180,7 +201,6 @@ class EffectsAnalyzer {
                 type: effectTypes.contractMetrics,
                 contract
             }
-            this.addEffect(metrics)
         }
         metrics[metric] = value
     }

package/src/index.js

@@ -19,16 +19,29 @@ const effectTypes = require('./effect-types')
  * @param {Boolean} [mapSac] - Whether to create a map SAC->Asset
  * @param {Boolean} [processSystemEvents] - Emit effects for contract errors and resource stats
  * @param {Boolean} [processFailedOpEffects] - Whether to generate operation effects for failed/rejected transactions
+ * @param {Boolean} [processMetrics] - Process invocation metrics emitted by Soroban
  * @param {Number} [protocol] - Specific Stellar protocol version for the executed transaction
  * @return {ParsedTxOperationsMetadata}
  */
-function parseTxOperationsMeta({network, tx, result, meta, mapSac = false, processSystemEvents = false, processFailedOpEffects = false, protocol}) {
+function parseTxOperationsMeta({
+                                   network,
+                                   tx,
+                                   result,
+                                   meta,
+                                   mapSac = false,
+                                   processSystemEvents = false,
+                                   processFailedOpEffects = false,
+                                   processMetrics,
+                                   protocol
+                               }) {
     if (!network)
         throw new TypeError(`Network passphrase argument is required.`)
     if (typeof network !== 'string')
         throw new TypeError(`Invalid network passphrase: "${network}".`)
     if (!tx)
         throw new TypeError(`Transaction envelope argument is required.`)
+    if (processMetrics !== false)
+        processMetrics = true
     const isEphemeral = !meta
     //parse tx, result, and meta xdr
     try {
@@ -132,10 +145,12 @@ function parseTxOperationsMeta({network, tx, result, meta, mapSac = false, proce
         const operation = parsedTx.operations[i]
         if (success || processFailedOpEffects) {
             const params = {
+                network,
                 operation,
                 meta: opMeta[i]?.changes() || [],
-                result: opResults[i], network,
-                processFailedOpEffects
+                result: opResults[i],
+                processFailedOpEffects,
+                processMetrics
             }
             const isSorobanInvocation = operation.type === 'invokeHostFunction'
             //only for Soroban contract invocation

package/src/parser/tx-xdr-parser-utils.js

@@ -280,8 +280,16 @@ function xdrParseScVal(value, treatBytesAsContractId = false) {
         case 'contractId':
             return xdrParseContractAddress(value._value)
         default:
-            if (value.switch().name === 'scvVoid') //scVoid
-                return undefined
+            switch (value._switch.name) {
+                case 'scvVoid':
+                    return undefined
+                case 'scvContractInstance':
+                    return '<ContractInstance>'
+                case 'scvLedgerKeyContractInstance':
+                    return '<LedgerKeyContractInstance>'
+                case 'scvLedgerKeyNonce':
+                    return '<LedgerKeyNonce>'
+            }
             throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value.toXDR ? value.toXDR() : value.toString())
     }
 }