@stellar-expert/tx-meta-effects-parser 5.7.1 → 6.0.1

package/package.json

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

package/src/effect-types.js

@@ -81,6 +81,7 @@ const effectTypes = {
     signerSponsorshipRemoved: 'signerSponsorshipRemoved',
 
     contractCodeUploaded: 'contractCodeUploaded',
+    contractCodeRemoved: 'contractCodeRemoved',
 
     contractCreated: 'contractCreated',
     contractUpdated: 'contractUpdated',
@@ -93,7 +94,9 @@ const effectTypes = {
     contractDataRemoved: 'contractDataRemoved',
 
     contractEvent: 'contractEvent',
-    contractMetrics: 'contractMetrics'
+    contractMetrics: 'contractMetrics',
+
+    setTtl: 'setTtl'
 }
 
 module.exports = effectTypes

package/src/effects-analyzer.js

@@ -8,6 +8,7 @@ const EventsAnalyzer = require('./aggregation/events-analyzer')
 const AssetSupplyAnalyzer = require('./aggregation/asset-supply-analyzer')
 const {mapSacContract} = require('./aggregation/sac-contract-mapper')
 const {UnexpectedTxMetaChangeError, TxMetaEffectParserError} = require('./errors')
+const {generateContractCodeEntryHash} = require('./parser/ledger-key')
 
 class EffectsAnalyzer {
     constructor({operation, meta, result, network, events, diagnosticEvents, mapSac, processSystemEvents, processFailedOpEffects}) {
@@ -95,16 +96,16 @@ class EffectsAnalyzer {
         if (parse) {
             parse.call(this)
         }
+        //process Soroban events
+        new EventsAnalyzer(this).analyze()
+        //process state data changes in the end
+        this.processStateChanges()
         //process ledger entry changes
         this.processChanges()
         //handle effects that are processed indirectly
         this.processSponsorshipEffects()
-        //process Soroban events
-        new EventsAnalyzer(this).analyze()
         //calculate minted/burned assets
         new AssetSupplyAnalyzer(this).analyze()
-        //process state data changes in the end
-        this.processStateChanges()
         return this.effects
     }
 
@@ -311,10 +312,10 @@ class EffectsAnalyzer {
 
     liquidityPoolDeposit() {
         const {liquidityPoolId} = this.operation
-        const {
-            before,
-            after
-        } = this.changes.find(ch => ch.type === 'liquidityPool' && ch.action === 'updated' && ch.after.pool === liquidityPoolId)
+        const poolUpdatedChanges = this.changes.find(ch => ch.type === 'liquidityPool' && ch.action === 'updated' && ch.after.pool === liquidityPoolId)
+        if (!poolUpdatedChanges) //tx failed
+            return
+        const {before, after} = poolUpdatedChanges
         this.addEffect({
             type: effectTypes.liquidityPoolDeposited,
             pool: this.operation.liquidityPoolId,
@@ -358,13 +359,16 @@ class EffectsAnalyzer {
                     this.addEffect(effect)
                 }
                 break
-            case 'wasm':
+            case 'wasm': {
+                const codeHash = hash(value)
                 this.addEffect({
                     type: effectTypes.contractCodeUploaded,
                     wasm: value.toString('base64'),
-                    wasmHash: hash(value).toString('hex')
+                    wasmHash: codeHash.toString('hex'),
+                    keyHash: generateContractCodeEntryHash(codeHash)
                 })
                 break
+            }
             case 'createContract':
                 const preimage = value.contractIdPreimage()
                 const executable = value.executable()
@@ -398,7 +402,7 @@ class EffectsAnalyzer {
                     default:
                         throw new TxMetaEffectParserError('Unknown contract type: ' + executableType)
                 }
-                this.addEffect(effect)
+                this.addEffect(effect, 0)
                 break
             default:
                 throw new TxMetaEffectParserError('Unknown host function call type: ' + func.arm())
@@ -765,7 +769,7 @@ class EffectsAnalyzer {
         const balanceEffects = this.effects.filter(e => (e.type === effectTypes.accountCredited || e.type === effectTypes.accountDebited) && e.source === account && e.asset === effect.owner)
         if (balanceEffects.length !== 1) //we can set balance only when we found 1-1 mapping, if there are several balance changes, we can't establish balance relation
             return
-        if (effect.type === effectTypes.contractDataRemoved) { //balance completely removed
+        if (effect.type === effectTypes.contractDataRemoved) { //balance completely removed - this may be a reversible operation if the balance simply expired
             balanceEffects[0].balance = '0'
             return
         }
@@ -782,8 +786,8 @@ class EffectsAnalyzer {
     processContractChanges({action, before, after}) {
         if (action !== 'created' && action !== 'updated')
             throw new UnexpectedTxMetaChangeError({type: 'contract', action})
-        const {kind, contract} = after
-        const effect = {
+        const {kind, owner: contract, keyHash} = after
+        let effect = {
             type: effectTypes.contractCreated,
             contract,
             kind
@@ -793,33 +797,38 @@ class EffectsAnalyzer {
                 effect.asset = after.asset
                 break
             case 'wasm':
-                effect.wasmHash = after.hash
+                effect.wasmHash = after.wasmHash
                 break
             default:
                 throw new TxMetaEffectParserError('Unexpected contract type: ' + kind)
         }
         if (action === 'created') {
-            if (this.effects.some(e => e.contract === contract))
-                return //skip contract creation effects processed by top-level createContract operation call
+            if (this.effects.some(e => e.type === effectTypes.contractCreated && e.contract === contract)) {
+                effect = undefined //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)
+            effect.prevWasmHash = before.wasmHash
+            if (before.wasmHash === after.wasmHash) {//skip if hash unchanged
+                effect = undefined
             }
-            if (before.hash === after.hash) //skip if hash unchanged
-                return
         }
-        this.addEffect(effect)
+        if (effect) {
+            this.addEffect(effect, effect.type === effectTypes.contractCreated ? 0 : undefined)
+        }
+        if (before?.storage?.length || after?.storage?.length) {
+            this.processInstanceDataChanges(before, after)
+        }
     }
 
     processContractStateEntryChanges({action, before, after}) {
-        const {owner, key, durability} = after || before
+        const {owner, key, durability, keyHash} = after || before
         const effect = {
             type: '',
             owner,
+            key,
             durability,
-            key
+            keyHash
         }
         switch (action) {
             case 'created':
@@ -842,9 +851,27 @@ class EffectsAnalyzer {
         this.processContractBalance(effect)
     }
 
+    processContractCodeChanges({type, action, before, after}) {
+        const {hash, keyHash} = after || before
+        switch (action) {
+            case 'created':
+                break //processed separately
+            case 'updated':
+                break //it doesn't change the state
+            case 'removed':
+                const effect = {
+                    type: effectTypes.contractCodeRemoved,
+                    wasmHash: hash,
+                    keyHash
+                }
+                this.addEffect(effect)
+                break
+        }
+    }
+
     processInstanceDataChanges(before, after) {
-        const storageBefore = before.storage || []
-        const storageAfter = [...(after.storage || [])]
+        const storageBefore = before?.storage || []
+        const storageAfter = [...(after?.storage || [])]
         for (const {key, val} of storageBefore) {
             let newVal
             for (let i = 0; i < storageAfter.length; i++) {
@@ -858,7 +885,7 @@ class EffectsAnalyzer {
             if (newVal === undefined) { //removed
                 const effect = {
                     type: effectTypes.contractDataRemoved,
-                    owner: after.contract || before.contract,
+                    owner: after?.owner || before.owner,
                     key,
                     prevValue: val,
                     durability: 'instance'
@@ -871,7 +898,7 @@ class EffectsAnalyzer {
 
             const effect = {
                 type: effectTypes.contractDataUpdated,
-                owner: after.contract || before.contract,
+                owner: after?.owner || before.owner,
                 key,
                 value: newVal,
                 prevValue: val,
@@ -883,7 +910,7 @@ class EffectsAnalyzer {
         for (const {key, val} of storageAfter) {
             const effect = {
                 type: effectTypes.contractDataCreated,
-                owner: after.contract || before.contract,
+                owner: after?.owner || before.owner,
                 key,
                 value: val,
                 durability: 'instance'
@@ -892,6 +919,27 @@ class EffectsAnalyzer {
         }
     }
 
+    processTtlChanges({action, before, after}) {
+        /*if (action === 'removed')
+            throw new UnexpectedTxMetaChangeError({type: 'ttl', action})*/
+        const {keyHash, ttl} = after || before
+        const stateEffect = this.effects.find(e => e.keyHash === keyHash && e.type !== effectTypes.setTtl)
+        const effect = {
+            type: effectTypes.setTtl,
+            keyHash,
+            ttl
+        }
+        if (stateEffect) {
+            if (stateEffect.type.includes('contractCode')) {
+                effect.kind = 'contractCode'
+            } else if (stateEffect.type.includes('contractData')) {
+                effect.kind = 'contractData'
+                effect.owner = stateEffect.owner
+            }
+        }
+        this.addEffect(effect)
+    }
+
     processChanges() {
         for (const change of this.changes)
             switch (change.type) {
@@ -914,10 +962,15 @@ class EffectsAnalyzer {
                     this.processDataEntryChanges(change)
                     break
                 case 'contractData':
-                    //this.processContractDataChanges(change)
+                    if (change.before?.kind || change.after?.kind) {
+                        this.processContractChanges(change)
+                    }
+                    break
+                case 'contractCode':
+                    this.processContractCodeChanges(change)
                     break
-                case 'contract':
-                    this.processContractChanges(change)
+                case 'ttl':
+                    this.processTtlChanges(change)
                     break
                 default:
                     throw new UnexpectedTxMetaChangeError(change)

package/src/index.js

@@ -26,7 +26,7 @@ function parseTxOperationsMeta({network, tx, result, meta, mapSac = false, proce
     if (!network)
         throw new TypeError(`Network passphrase argument is required.`)
     if (typeof network !== 'string')
-        throw new TypeError(`Invalid network passphrase or identifier: "${network}".`)
+        throw new TypeError(`Invalid network passphrase: "${network}".`)
     if (!tx)
         throw new TypeError(`Transaction envelope argument is required.`)
     const isEphemeral = !meta

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

@@ -1,10 +1,11 @@
 const {StrKey} = require('@stellar/stellar-base')
-const {TxMetaEffectParserError} = require('../errors')
+const {TxMetaEffectParserError, UnexpectedTxMetaChangeError} = require('../errors')
 const {xdrParseAsset, xdrParseAccountAddress, xdrParseClaimant, xdrParsePrice, xdrParseSignerKey} = require('./tx-xdr-parser-utils')
+const {generateContractStateEntryHash, generateContractCodeEntryHash} = require('./ledger-key')
 
 /**
  * @typedef {{}} ParsedLedgerEntryMeta
- * @property {'account'|'trustline'|'offer'|'data'|'liquidityPool'|'claimableBalance'|'contractData'|'contractCode'} type - Ledger entry type
+ * @property {'account'|'trustline'|'offer'|'data'|'liquidityPool'|'claimableBalance'|'contractData'|'contractCode'|'ttl'} type - Ledger entry type
  * @property {'created'|'updated'|'removed'} action - Ledger modification action
  * @property {{}} before - Ledger entry state before changes applied
  * @property {{}} after - Ledger entry state after changes application
@@ -19,35 +20,39 @@ function parseLedgerEntryChanges(ledgerEntryChanges) {
     let state
     for (let i = 0; i < ledgerEntryChanges.length; i++) {
         const entry = ledgerEntryChanges[i]
-        const actionType = entry.arm()
-
-        const stateData = parseEntry(entry.value(), actionType)
+        const action = entry._arm
+        const stateData = parseEntry(entry, action)
         if (stateData === undefined)
             continue
-        const change = {action: actionType}
-        switch (actionType) {
+        const change = {action}
+        const type = entry._value._arm
+        switch (action) {
             case 'state':
                 state = stateData
                 continue
             case 'created':
+                if (type === 'contractCode')
+                    continue //processed in operation handler
                 change.before = null
                 change.after = stateData
                 change.type = stateData.entry
                 break
             case 'updated':
+                if (type === 'contractCode')
+                    throw new UnexpectedTxMetaChangeError({type, action})
                 change.before = state
                 change.after = stateData
                 change.type = stateData.entry
                 break
             case 'removed':
-                if (!state && entry._value._arm === 'ttl')
+                if (!state && type === 'ttl')
                     continue //skip expiration processing for now
                 change.before = state
                 change.after = null
                 change.type = state.entry
                 break
             default:
-                throw new TxMetaEffectParserError(`Unknown change entry type: ${actionType}`)
+                throw new TxMetaEffectParserError(`Unknown change entry type: ${action}`)
         }
         changes.push(change)
         state = null
@@ -57,12 +62,13 @@ function parseLedgerEntryChanges(ledgerEntryChanges) {
 
 function parseEntry(entry, actionType) {
     if (actionType === 'removed')
-        return null //parseEntryData(entry)
-    const parsed = parseEntryData(entry.data())
+        return null
+    const value = entry.value()
+    const parsed = parseEntryData(value.data())
     if (parsed === null)
         return null
     //parsed.modified = entry.lastModifiedLedgerSeq()
-    return parseLedgerEntryExt(parsed, entry)
+    return parseLedgerEntryExt(parsed, value)
 }
 
 function parseEntryData(data) {
@@ -85,9 +91,9 @@ function parseEntryData(data) {
         case 'contractData':
             return parseContractData(data)
         case 'contractCode':
-            return undefined
+            return parseContractCode(data)
         case 'ttl':
-            return undefined
+            return parseTtl(data)
         default:
             throw new TxMetaEffectParserError(`Unknown meta entry type: ${updatedEntryType}`)
     }
@@ -240,46 +246,51 @@ function parseContractData(value) {
     const owner = parseStateOwnerDataAddress(data.contract())
 
     const valueAttr = data.val()
-    switch (data.key().switch()?.name) {
-        case 'scvLedgerKeyContractInstance':
-            const entry = {
-                entry: 'contract',
-                contract: owner
-            }
-            const instance = valueAttr.instance()._attributes
-            const type = instance.executable._switch.name
-            switch (type) {
-                case 'contractExecutableStellarAsset':
-                    entry.kind = 'fromAsset'
-                    if (!instance.storage?.length)
-                        return undefined //likely the asset has been created "fromAddress" - no metadata in this case
+    const entry = {
+        entry: 'contractData',
+        owner,
+        key: data.key().toXDR('base64'),
+        value: valueAttr.toXDR('base64'),
+        durability: data.durability().name,
+        keyHash: generateContractStateEntryHash(data)
+    }
+    if (data.key().switch()?.name === 'scvLedgerKeyContractInstance' && entry.durability === 'persistent') {
+        entry.durability = 'instance'
+        const instance = valueAttr.instance()._attributes
+        const type = instance.executable._switch.name
+        switch (type) {
+            case 'contractExecutableStellarAsset':
+                entry.kind = 'fromAsset'
+                if (instance.storage?.length) { //if not -- the asset has been created "fromAddress" - no metadata in this case
                     const metaArgs = instance.storage[0]._attributes
                     if (metaArgs.key._value.toString() !== 'METADATA')
                         throw new TxMetaEffectParserError('Unexpected asset initialization metadata')
                     entry.asset = xdrParseAsset(metaArgs.val._value[1]._attributes.val._value.toString())
-                    break
-                case 'contractExecutableWasm':
-                    entry.kind = 'wasm'
-                    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)
-            }
-            return entry
+                }
+                break
+            case 'contractExecutableWasm':
+                entry.kind = 'wasm'
+                entry.wasmHash = instance.executable.wasmHash().toString('hex')
+                break
+            default:
+                throw new TxMetaEffectParserError('Unsupported executable type: ' + type)
+        }
+        if (instance.storage?.length) {
+            entry.storage = instance.storage.map(entry => ({
+                key: entry.key().toXDR('base64'),
+                val: entry.val().toXDR('base64')
+            }))
+        }
     }
+    return entry
+}
 
+function parseTtl(data) {
+    const attrs = data._value._attributes
     return {
-        entry: 'contractData',
-        owner,
-        key: data.key().toXDR('base64'),
-        value: valueAttr.toXDR('base64'),
-        durability: data.durability().name
+        entry: 'ttl',
+        keyHash: attrs.keyHash.toString('hex'),
+        ttl: attrs.liveUntilLedgerSeq
     }
 }
 
@@ -289,13 +300,14 @@ function parseStateOwnerDataAddress(contract) {
     return xdrParseAccountAddress(contract.accountId())
 }
 
-/*function parseContractCode(value) {
+function parseContractCode(value) {
     const contract = value.value()
+    const hash = contract.hash()
     return {
         entry: 'contractCode',
-        hash: contract.hash().toString('hex'),
-        code: contract.body().code().toString('base64')
+        hash: hash.toString('hex'),
+        keyHash: generateContractCodeEntryHash(hash)
     }
-}*/
+}
 
 module.exports = {parseLedgerEntryChanges}

package/src/parser/ledger-key.js

@@ -0,0 +1,19 @@
+const {xdr, hash} = require('@stellar/stellar-base')
+
+function generateContractStateEntryHash(data) {
+    const {contract, durability, key} = data._attributes
+    const contractDataKey = new xdr.LedgerKeyContractData({contract, durability, key})
+    const ledgerKey = xdr.LedgerKey.contractData(contractDataKey)
+    return hash(ledgerKey.toXDR()).toString('hex')
+}
+
+function generateContractCodeEntryHash(wasmHash) {
+    const contractDataKey = new xdr.LedgerKeyContractCode({hash: wasmHash})
+    const ledgerKey = xdr.LedgerKey.contractCode(contractDataKey)
+    return hash(ledgerKey.toXDR()).toString('hex')
+}
+
+module.exports = {
+    generateContractStateEntryHash,
+    generateContractCodeEntryHash
+}

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

@@ -234,7 +234,6 @@ function xdrParseAsset(src) {
         return `${src.code}-${src.issuer}-${src.type || (src.code.length > 4 ? 2 : 1)}`
 }
 
-
 function xdrParseScVal(value, treatBytesAsContractId = false) {
     if (typeof value === 'string') {
         value = xdr.ScVal.fromXDR(value, 'base64')