@stellar-expert/tx-meta-effects-parser 5.5.3 → 5.6.0

package/package.json

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

package/src/aggregation/events-analyzer.js

@@ -1,7 +1,6 @@
 const {StrKey} = require('@stellar/stellar-base')
 const effectTypes = require('../effect-types')
 const {xdrParseScVal, xdrParseAsset, isContractAddress} = require('../parser/tx-xdr-parser-utils')
-const {contractIdFromPreimage} = require('../parser/contract-preimage-encoder')
 const {mapSacContract} = require('./sac-contract-mapper')
 
 const EVENT_TYPES = {
@@ -65,7 +64,7 @@ class EventsAnalyzer {
         const {diagnosticEvents, processSystemEvents} = this.effectsAnalyzer
         if (!diagnosticEvents)
             return
-        const opContractId = retrieveOpContractId(this.effectsAnalyzer.operation, this.effectsAnalyzer.network)
+        const opContractId = this.effectsAnalyzer.retrieveOpContractId()
         //diagnostic events
         for (const evt of diagnosticEvents) {
             if (!processSystemEvents && !evt.inSuccessfulContractCall())
@@ -156,30 +155,27 @@ class EventsAnalyzer {
                         classicAsset = null  //not an SAC event
                     }
                 }
-                if (classicAsset && (classicAsset.includes(from) || classicAsset.includes(to))) { //SAC transfer by asset issuer
-                    if (classicAsset.includes(from)) {
-                        this.effectsAnalyzer.mint(contract, amount)
-                        this.effectsAnalyzer.credit(amount, isContractAddress(to) ? contract : classicAsset, to)
-                    }
-                    if (classicAsset.includes(to)) {
-                        this.effectsAnalyzer.debit(amount, isContractAddress(from) ? contract : classicAsset, from)
-                        this.effectsAnalyzer.burn(contract, amount)
+                if (classicAsset) {
+                    if (classicAsset.includes(from)) {  //SAC transfer by asset issuer
+                        this.effectsAnalyzer.mint(classicAsset, amount)
+                        this.effectsAnalyzer.credit(amount, classicAsset, to)
+                        return
                     }
-                } else { //other cases
-                    if (classicAsset && !isContractAddress(from)) { //classic asset bridged to Soroban
+                    if (classicAsset.includes(to)) {  //SAC transfer by asset issuer
+                        this.effectsAnalyzer.debit(amount, classicAsset, from)
                         this.effectsAnalyzer.burn(classicAsset, amount)
-                        this.effectsAnalyzer.mint(contract, amount)
-                    } else {
-                        this.effectsAnalyzer.debit(amount, contract, from)
+                        return
                     }
-                    if (classicAsset && !isContractAddress(to)) { //classic asset bridged from Soroban
-                        this.effectsAnalyzer.burn(contract, amount)
-                        this.effectsAnalyzer.mint(classicAsset, amount)
-                    } else {
-                        this.effectsAnalyzer.credit(amount, contract, to)
+                    if (isContractAddress(from)) {
+                        this.effectsAnalyzer.debit(amount, classicAsset, from)
+                    }
+                    if (isContractAddress(to)) {
+                        this.effectsAnalyzer.credit(amount, classicAsset, to)
                     }
+                } else { //other cases
+                    this.effectsAnalyzer.debit(amount, this.effectsAnalyzer.resolveAsset(contract), from)
+                    this.effectsAnalyzer.credit(amount, this.effectsAnalyzer.resolveAsset(contract), to)
                 }
-
             }
                 break
             case 'mint': {
@@ -189,15 +185,14 @@ class EventsAnalyzer {
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'mint' && matchArrays([to, amount], e.args)))
                     return
-                this.effectsAnalyzer.addEffect({
-                    type: effectTypes.assetMinted,
-                    asset: contract,
-                    amount
-                })
-                this.effectsAnalyzer.credit(amount, contract, to)
                 if (topics.length > 3) {
                     mapSacContract(this.effectsAnalyzer, contract, xdrParseAsset(xdrParseScVal(topics[3])))
                 }
+                const asset = this.effectsAnalyzer.resolveAsset(contract)
+                this.effectsAnalyzer.mint(asset, amount)
+                if (isContractAddress(asset)) {
+                    this.effectsAnalyzer.credit(amount, asset, to)
+                }
             }
                 break
             case 'burn': {
@@ -210,12 +205,14 @@ class EventsAnalyzer {
                     (e.function === 'burn_from' && matchArrays([undefined, from, amount], e.args))
                 ))
                     return
-
-                this.effectsAnalyzer.debit(amount, contract, from)
-                this.effectsAnalyzer.burn(contract, amount)
                 if (topics.length > 2) {
                     mapSacContract(this.effectsAnalyzer, contract, xdrParseAsset(xdrParseScVal(topics[2])))
                 }
+                const asset = this.effectsAnalyzer.resolveAsset(contract)
+                if (isContractAddress(asset)) {
+                    this.effectsAnalyzer.debit(amount, asset, from)
+                }
+                this.effectsAnalyzer.burn(asset, amount)
             }
                 break
             case 'clawback': {
@@ -225,11 +222,14 @@ class EventsAnalyzer {
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'clawback' && matchArrays([from, amount], e.args)))
                     return
-                this.effectsAnalyzer.debit(amount, contract, from)
-                this.effectsAnalyzer.burn(contract, amount)
                 if (topics.length > 3) {
                     mapSacContract(this.effectsAnalyzer, contract, xdrParseAsset(xdrParseScVal(topics[3])))
                 }
+                const asset = this.effectsAnalyzer.resolveAsset(contract)
+                if (isContractAddress(asset)) {
+                    this.effectsAnalyzer.debit(amount, asset, from)
+                }
+                this.effectsAnalyzer.burn(asset, amount)
             }
                 break
             case 'set_admin': {
@@ -239,10 +239,10 @@ class EventsAnalyzer {
                 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(contract, newAdmin)
                 if (topics.length > 2) {
                     mapSacContract(this.effectsAnalyzer, contract, xdrParseAsset(xdrParseScVal(topics[2])))
                 }
+                this.effectsAnalyzer.setAdmin(contract, newAdmin)
             }
                 break
             /*case 'approve': { //TODO: think about processing this effect
@@ -305,18 +305,4 @@ function processEventBodyValue(value) {
     return xdrParseScVal(value) //other scValue
 }
 
-function retrieveOpContractId(operation, network) {
-    const funcValue = operation.func._value._attributes
-    if (!funcValue)
-        return null //WASM upload
-    let address = funcValue.contractAddress?._value
-    if (!address) {
-        const preimage = funcValue.contractIdPreimage
-        if (preimage) {
-            address = contractIdFromPreimage(preimage, network)
-        }
-    }
-    return address
-}
-
 module.exports = EventsAnalyzer

package/src/aggregation/sac-contract-mapper.js

@@ -15,14 +15,22 @@ function mapSacContract(effectsAnalyzer, contractAddress, classicAsset) {
     if (!classicAsset)
         return false
     const {network, sacMap} = effectsAnalyzer
+    if (!sacMap)
+        return false
+    const prevMapping = sacMap[contractAddress]
+    if (prevMapping) {
+        return prevMapping === classicAsset
+    }
     //try to load from cache first
-    const fromCache = sacCache.get(contractAddress + network)
+    const fromCache = sacCache.get(classicAsset + network)
     if (!fromCache) {
         const encodedContract = contractIdFromAsset(toStellarAsset(classicAsset), network)
-        sacCache.set(encodedContract + network, classicAsset)
-        if (encodedContract !== contractAddress)
+        sacCache.set(classicAsset + network, contractAddress)
+        if (contractAddress === undefined) {
+            contractAddress = encodedContract
+        } else if (encodedContract !== contractAddress)
             return false
-    } else if (classicAsset !== fromCache)
+    } else if (contractAddress !== fromCache)
         return false //check whether validated contract from cache matches the asset
     if (sacMap) {
         sacMap[contractAddress] = classicAsset

package/src/effects-analyzer.js

@@ -7,6 +7,7 @@ const {contractIdFromPreimage} = require('./parser/contract-preimage-encoder')
 const EventsAnalyzer = require('./aggregation/events-analyzer')
 const AssetSupplyAnalyzer = require('./aggregation/asset-supply-analyzer')
 const {UnexpectedTxMetaChangeError, TxMetaEffectParserError} = require('./errors')
+const {mapSacContract} = require('./aggregation/sac-contract-mapper')
 
 class EffectsAnalyzer {
     constructor({operation, meta, result, network, events, diagnosticEvents, mapSac, processSystemEvents}) {
@@ -194,8 +195,7 @@ class EffectsAnalyzer {
                 refundable: parseLargeInt(attrs.totalRefundableResourceFeeCharged),
                 rent: parseLargeInt(attrs.rentFeeCharged)
             }
-            const contract = StrKey.encodeContract(this.operation.func._value.contractAddress()._value)
-            this.addMetric(contract, 'fee', fee)
+            this.addMetric(this.retrieveOpContractId(), 'fee', fee)
         }
     }
 
@@ -572,6 +572,9 @@ class EffectsAnalyzer {
     }
 
     processBalanceChange(account, asset, beforeBalance, afterBalance) {
+        if (this.isContractCall) { //map contract=>asset proactively
+            mapSacContract(this, undefined, asset)
+        }
         const balanceChange = BigInt(afterBalance) - BigInt(beforeBalance)
         if (balanceChange < 0n) {
             this.debit((-balanceChange).toString(), asset, account, afterBalance)
@@ -911,6 +914,25 @@ class EffectsAnalyzer {
                     throw new UnexpectedTxMetaChangeError(change)
             }
     }
+
+    retrieveOpContractId() {
+        const funcValue = this.operation.func._value._attributes
+        if (funcValue) {
+            if (funcValue.contractAddress)
+                return StrKey.encodeContract(funcValue.contractAddress._value)
+            const preimage = funcValue.contractIdPreimage
+            if (preimage)
+                return contractIdFromPreimage(preimage, this.network)
+        }
+        return null
+    }
+
+    resolveAsset(assetOrContract) {
+        if (!assetOrContract.startsWith('C') || !this.sacMap)
+            return assetOrContract
+        //try to resolve using SAC map
+        return this.sacMap[assetOrContract] || assetOrContract
+    }
 }
 
 /**