@stellar-expert/tx-meta-effects-parser 5.0.4 → 5.1.1

package/package.json

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

package/src/asset-supply-processor.js

@@ -8,7 +8,7 @@ class AssetSupplyProcessor {
      * @param {EffectsAnalyzer} effectsAnalyzer
      */
     constructor(effectsAnalyzer) {
-        this.assetTransfers = {}
+        this.assetTransfers = new Map()
         this.processXlmBalances = effectsAnalyzer.isContractCall
         this.effectsAnalyzer = effectsAnalyzer
     }
@@ -19,7 +19,7 @@ class AssetSupplyProcessor {
      */
     effectsAnalyzer
     /**
-     * @type {Object.<String,BigInt>}
+     * @type {Map<String,BigInt>}
      * @private
      */
     assetTransfers
@@ -28,6 +28,32 @@ class AssetSupplyProcessor {
      * @private
      */
     processXlmBalances = false
+    /**
+     * @type {Number}
+     * @private
+     */
+    supplyChanges = 0
+
+    /**
+     * Calculate differences and generate minted/burned effects if needed
+     */
+    analyze() {
+        for (const effect of this.effectsAnalyzer.effects) {
+            this.processEffect(effect)
+        }
+        for (const [asset, amount] of this.assetTransfers.entries()) {
+            if (amount > 0n) {
+                this.effectsAnalyzer.mint(asset, amount.toString(), true)
+                this.supplyChanges |= 2
+            } else if (amount < 0n) {
+                this.effectsAnalyzer.burn(asset, (-amount).toString())
+                this.supplyChanges |= 1
+            }
+        }
+        if ((this.supplyChanges & 3) === 3) { //analyze possible collapsible mints only if both mint and burn effects recorded
+            new CollapsibleMintsAnalyzer(this.effectsAnalyzer).removeCollapsingMints()
+        }
+    }
 
     /**
      * Process generated operation effect
@@ -37,15 +63,23 @@ class AssetSupplyProcessor {
         switch (effect.type) {
             case effectTypes.accountCredited:
             case effectTypes.claimableBalanceCreated:
+                //increase supply
+                this.increase(effect.asset, effect.amount)
+                break
             case effectTypes.assetBurned:
                 //increase supply
                 this.increase(effect.asset, effect.amount)
+                this.supplyChanges |= 1
                 break
             case effectTypes.accountDebited:
             case effectTypes.claimableBalanceRemoved:
+                //decrease supply
+                this.decrease(effect.asset, effect.amount)
+                break
             case effectTypes.assetMinted:
                 //decrease supply
                 this.decrease(effect.asset, effect.amount)
+                this.supplyChanges |= 2
                 break
             case effectTypes.liquidityPoolDeposited:
                 //increase supply for every deposited asset (if liquidity provider is an issuer)
@@ -73,22 +107,6 @@ class AssetSupplyProcessor {
         }
     }
 
-    /**
-     * Calculate differences and generate minted/burned effects if needed
-     */
-    analyze() {
-        for (const effect of this.effectsAnalyzer.effects) {
-            this.processEffect(effect)
-        }
-        for (const [asset, amount] of Object.entries(this.assetTransfers)) {
-            if (amount > 0n) {
-                this.effectsAnalyzer.mint(asset, amount.toString(), true)
-            } else if (amount < 0n) {
-                this.effectsAnalyzer.burn(asset, (-amount).toString())
-            }
-        }
-    }
-
     /**
      * @param {String} asset
      * @param {String} amount
@@ -97,7 +115,7 @@ class AssetSupplyProcessor {
     increase(asset, amount) {
         if (!this.shouldProcessAsset(asset))
             return
-        this.assetTransfers[asset] = (this.assetTransfers[asset] || 0n) + BigInt(amount)
+        this.assetTransfers.set(asset, (this.assetTransfers.get(asset) || 0n) + BigInt(amount))
     }
 
     /**
@@ -108,7 +126,7 @@ class AssetSupplyProcessor {
     decrease(asset, amount) {
         if (!this.shouldProcessAsset(asset))
             return
-        this.assetTransfers[asset] = (this.assetTransfers[asset] || 0n) - BigInt(amount)
+        this.assetTransfers.set(asset, (this.assetTransfers.get(asset) || 0n) - BigInt(amount))
     }
 
     /**
@@ -122,4 +140,65 @@ class AssetSupplyProcessor {
     }
 }
 
+class CollapsibleMintsAnalyzer {
+    /**
+     * @param {EffectsAnalyzer} effectsAnalyzer
+     */
+    constructor(effectsAnalyzer) {
+        this.effectsAnalyzer = effectsAnalyzer
+        this.supply = new Map()
+    }
+
+    /**
+     * @type {EffectsAnalyzer}
+     * @private
+     */
+    effectsAnalyzer
+    /**
+     * @type {Map<String,[]>}
+     * @private
+     */
+    supply
+
+    removeCollapsingMints() {
+        const {effects} = this.effectsAnalyzer
+        for (const effect of effects) {
+            if (effect.type === effectTypes.assetMinted || effect.type === effectTypes.assetBurned) {
+                this.addEffectToSupplyCounter(effect)
+            }
+        }
+        for (const [asset, assetEffects] of this.supply.entries()) {
+            if (assetEffects.length < 2)
+                continue //skip non-collapsible effects
+            //aggregate amount
+            let sum = 0n
+            let position
+            for (const effect of assetEffects) {
+                sum += effect.type === effectTypes.assetMinted ? BigInt(effect.amount) : -BigInt(effect.amount) //add to the running total
+                position = effects.indexOf(effect) //find effect position in the parent effects container
+                effects.splice(position, 1) //remove the effect from the parent container
+            }
+            if (sum > 0n) { //asset minted
+                this.effectsAnalyzer.mint(asset, sum.toString(), true) //insert mint effect
+            } else if (sum < 0n) { //asset burned
+                this.effectsAnalyzer.burn(asset, sum.toString(), position) //insert burn effect at the position of the last removed effect
+            }
+            //if sum=0 then both effects were annihilated and removed
+        }
+    }
+
+    /**
+     * @param {{}} effect
+     * @private
+     */
+    addEffectToSupplyCounter(effect) {
+        let container = this.supply.get(effect.asset)
+        if (!container) {
+            container = []
+            this.supply.set(effect.asset, container)
+        }
+        container.push(effect)
+    }
+}
+
 module.exports = AssetSupplyProcessor

package/src/events-analyzer.js

@@ -161,7 +161,7 @@ class EventsAnalyzer {
             case 'mint': {
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     return //throw new Error('Non-standard event')
-                const to = xdrParseScVal(topics[1])
+                const to = xdrParseScVal(topics[2])
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'mint' && matchArrays([to, amount], e.args)))
                     return
@@ -191,7 +191,6 @@ class EventsAnalyzer {
             case 'clawback': {
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     return //throw new Error('Non-standard event')
-                const admin = xdrParseScVal(topics[1])
                 const from = xdrParseScVal(topics[2])
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'clawback' && matchArrays([from, amount], e.args)))

package/src/ledger-entry-changes-parser.js

@@ -298,7 +298,14 @@ function parseContractData(value) {
                     break
                 case 'contractExecutableWasm':
                     entry.kind = 'wasm'
-                    entry.hash = valueAttr.instance().executable().wasmHash().toString('hex')
+                    const instance = valueAttr.instance()._attributes
+                    entry.hash = instance.executable.wasmHash().toString('hex')
+                    if (instance.storage?.length) {
+                        entry.storage = instance.storage.map(entry => ({
+                            key: entry.key().toXDR('base64'),
+                            val: entry.val().toXDR('base64')
+                        }))
+                    }
                     break
                 default:
                     throw new TxMetaEffectParserError('Unsupported executable type: ' + type)

package/src/tx-effects-analyzer.js

@@ -145,12 +145,12 @@ class EffectsAnalyzer {
         }, position)
     }
 
-    burn(asset, amount) {
+    burn(asset, amount, position = undefined) {
         this.addEffect({
             type: effectTypes.assetBurned,
             asset,
             amount
-        })
+        }, position)
     }
 
     setOptions() {
@@ -694,33 +694,6 @@ class EffectsAnalyzer {
         this.addEffect(effect)
     }
 
-    processContractDataChanges({action, before, after}) {
-        const {owner, key, value, durability} = after || before
-        const effect = {
-            type: '',
-            owner,
-            key,
-            value,
-            durability
-        }
-        switch (action) {
-            case 'created':
-                effect.type = effectTypes.contractDataCreated
-                break
-            case 'updated':
-                if (before.value === after.value)
-                    return //value has not changed
-                effect.type = effectTypes.contractDataUpdated
-                break
-            case 'removed':
-                effect.type = effectTypes.contractDataRemoved
-                delete effect.value
-                break
-        }
-        this.addEffect(effect)
-        this.processContractBalance(effect)
-    }
-
     processContractBalance(effect) {
         const parsedKey = xdr.ScVal.fromXDR(effect.key, 'base64')
         if (parsedKey._arm !== 'vec')
@@ -748,22 +721,108 @@ class EffectsAnalyzer {
         balanceEffects[0].balance = parsedValue.amount
     }
 
-    processContractChanges({action, after}) {
-        if (action === 'updated')
-            return // TODO: check whether any contract properties changed
-        if (action !== 'created')
+    processContractChanges({action, before, after}) {
+        if (action !== 'created' && action !== 'updated')
             throw new UnexpectedTxMetaChangeError({type: 'contract', action})
         const {kind, contract, hash} = after
-        if (this.effects.some(e => e.contract === contract))
-            return //skip contract creation effects processed by top-level createContract operation call
         const effect = {
             type: effectTypes.contractCreated,
             contract,
             kind,
             wasmHash: hash
         }
+        if (action === 'created') {
+            if (this.effects.some(e => e.contract === contract))
+                return //skip contract creation effects processed by top-level createContract operation call
+        } else if (action === 'updated') {
+            effect.type = effectTypes.contractUpdated
+            effect.prevWasmHash = before.hash
+            if (before.storage?.length || after.storage?.length) {
+                this.processInstanceDataChanges(before, after)
+            }
+            if (before.hash === hash) //skip if hash unchanged
+                return
+        }
+        this.addEffect(effect)
+    }
+
+    processContractDataChanges({action, before, after}) {
+        const {owner, key, durability} = after || before
+        const effect = {
+            type: '',
+            owner,
+            durability,
+            key
+        }
+        switch (action) {
+            case 'created':
+                effect.type = effectTypes.contractDataCreated
+                effect.value = after.value
+                break
+            case 'updated':
+                if (before.value === after.value)
+                    return //value has not changed
+                effect.type = effectTypes.contractDataUpdated
+                effect.value = after.value
+                effect.prevValue = before.value
+                break
+            case 'removed':
+                effect.type = effectTypes.contractDataRemoved
+                effect.prevValue = before.value
+                break
+        }
         this.addEffect(effect)
+        this.processContractBalance(effect)
+    }
 
+    processInstanceDataChanges(before, after) {
+        const storageBefore = before.storage || []
+        const storageAfter = [...(after.storage || [])]
+        for (const {key, val} of storageBefore) {
+            let newVal
+            for (let i = 0; i < storageAfter.length; i++) {
+                const afterValue = storageAfter[i]
+                if (afterValue.key === key) {
+                    newVal = afterValue.val //update new value
+                    storageAfter.splice(i, 1) //remove from array to simplify iteration
+                    break
+                }
+            }
+            if (newVal === undefined) { //removed
+                const effect = {
+                    type: effectTypes.contractDataRemoved,
+                    owner: after.contract || before.contract,
+                    key,
+                    prevValue: val,
+                    durability: 'instance'
+                }
+                this.addEffect(effect)
+                continue
+            }
+            if (val === newVal) //value has not changed
+                continue
+
+            const effect = {
+                type: effectTypes.contractDataUpdated,
+                owner: after.contract || before.contract,
+                key,
+                value: newVal,
+                prevValue: val,
+                durability: 'instance'
+            }
+            this.addEffect(effect)
+        }
+        //iterate all storage items left
+        for (const {key, val} of storageAfter) {
+            const effect = {
+                type: effectTypes.contractDataCreated,
+                owner: after.contract || before.contract,
+                key,
+                value: val,
+                durability: 'instance'
+            }
+            this.addEffect(effect)
+        }
     }
 
     processChanges() {