@stellar-expert/tx-meta-effects-parser 9.0.0 → 9.2.0

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@stellar-expert/tx-meta-effects-parser",
-  "version": "9.0.0",
+  "version": "9.2.0",
   "description": "Low-level effects parser for Stellar transaction results and meta XDR",
   "main": "src/index.js",
+  "author": "team@stellar.expert",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stellar-expert/tx-meta-effects-parser.git"
+  },
+  "bugs": "https://github.com/stellar-expert/tx-meta-effects-parser/issues",
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
-  "author": "team@stellar.expert",
-  "license": "MIT",
   "peerDependencies": {
     "@stellar/stellar-sdk": ">=16"
   },

package/src/effects-analyzer.js

@@ -144,7 +144,7 @@ class EffectsAnalyzer {
         if (!effect.source) {
             effect.source = this.source
         }
-        if (atPosition !== undefined) {
+        if (atPosition >= 0) {
             this.effects.splice(atPosition < 0 ? 0 : atPosition, 0, effect)
         } else {
             this.effects.push(effect)
@@ -413,46 +413,7 @@ class EffectsAnalyzer {
                 break
             }
             case 'createContract':
-            case 'createContractV2':
-                const preimage = value.contractIdPreimage()
-                const executable = value.executable()
-                const executableType = executable.switch().name
-
-                const effect = {
-                    type: effectTypes.contractCreated,
-                    contract: contractIdFromPreimage(preimage, this.network)
-                }
-                switch (executableType) {
-                    case 'contractExecutableWasm':
-                        effect.kind = 'wasm'
-                        effect.wasmHash = executable.wasmHash().toString('hex')
-                        break
-                    case 'contractExecutableStellarAsset':
-                        const preimageParams = preimage.value()
-                        switch (preimage.switch().name) {
-                            case 'contractIdPreimageFromAddress':
-                                effect.kind = 'fromAddress'
-                                effect.issuer = xdrParseAccountAddress(preimageParams.address().value())
-                                effect.salt = preimageParams.salt().toString('base64')
-                                break
-                            case 'contractIdPreimageFromAsset':
-                                effect.kind = 'fromAsset'
-                                effect.asset = xdrParseAsset(preimageParams)
-                                break
-                            default:
-                                throw new TxMetaEffectParserError('Unknown preimage type: ' + preimage.switch().name)
-                        }
-                        break
-                    default:
-                        throw new TxMetaEffectParserError('Unknown contract type: ' + executableType)
-                }
-                if (func.arm() === 'createContractV2') {
-                    const args = value.constructorArgs() //array
-                    if (args.length > 0) {
-                        effect.constructorArgs = args.map(arg => arg.toXDR('base64'))
-                    }
-                }
-                this.addEffect(effect, 0)
+            case 'createContractV2': //handled in entry changes
                 break
             default:
                 throw new TxMetaEffectParserError('Unknown host function call type: ' + func.arm())
@@ -539,8 +500,12 @@ class EffectsAnalyzer {
                     effect.balance = before?.balanceId || after?.balanceId
                     //TODO: add claimable balance asset to the effect
                     break
-                case 'liquidityPool': //ignore??
-                    continue
+                case 'liquidityPool':
+                    //sponsored liquidity pool entry is never removed, so only created/updated effects are emitted
+                    if (action !== 'created' && action !== 'updated')
+                        continue
+                    effect.pool = before?.pool || after?.pool
+                    break
             }
             effect.type = encodeSponsorshipEffectName(action, type)
             this.addEffect(effect)
@@ -828,9 +793,6 @@ class EffectsAnalyzer {
         }
         switch (action) {
             case 'created':
-                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
-                }
                 break
             case 'updated':
                 effect.type = effectTypes.contractUpdated
@@ -846,7 +808,7 @@ class EffectsAnalyzer {
                 throw new UnexpectedTxMetaChangeError({type: 'contract', action})
         }
         if (effect) {
-            this.addEffect(effect, effect.type === effectTypes.contractCreated ? 0 : undefined)
+            this.addEffect(effect, effect.type === effectTypes.contractCreated ? this.effects.findIndex(e => e.contract === effect.contract || e.owner === effect.contract) : undefined)
         }
         if (before?.storage?.length || after?.storage?.length) {
             this.processInstanceDataChanges(before, after, action === 'restored')
@@ -896,9 +858,19 @@ class EffectsAnalyzer {
     }
 
     processContractCodeChanges({type, action, before, after}) {
-        const {hash, keyHash} = after || before
+        const {hash, keyHash, wasm} = after || before
         switch (action) {
             case 'created':
+                //ensure that the effect was not processed by the top-level createContract operation call
+                if (!this.effects.some(e => e.type === effectTypes.contractCodeUploaded && e.keyHash === keyHash)) {
+                    const effect = {
+                        type: effectTypes.contractCodeUploaded,
+                        wasm,
+                        wasmHash: hash,
+                        keyHash
+                    }
+                    this.addEffect(effect)
+                }
                 break //processed separately
             case 'updated':
                 break //it doesn't change the state
@@ -971,28 +943,27 @@ class EffectsAnalyzer {
         }
     }
 
-    processTtlChanges({action, before, after}) {
-        /*if (action === 'removed')
-            throw new UnexpectedTxMetaChangeError({type: 'ttl', action})*/
+    processTtlChanges({before, after}) {
         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.startsWith('contractCode')) {
-                effect.kind = 'contractCode'
-            } else if (stateEffect.type.startsWith('contractData')) {
-                effect.kind = 'contractData'
-                effect.owner = stateEffect.owner
-            } else if (stateEffect.type.startsWith('contract')) {
-                effect.kind = 'contractData'
-                effect.owner = stateEffect.contract
-            } else
-                throw new UnexpectedTxMetaChangeError({type: 'ttl', action: stateEffect.type})
-            stateEffect.ttl = ttl
+        for (const emitted of this.effects) {
+            if (emitted.keyHash === keyHash && emitted.type !== effectTypes.setTtl) {
+                if (emitted.type.startsWith('contractCode')) {
+                    effect.kind = 'contractCode'
+                } else if (emitted.type.startsWith('contractData')) {
+                    effect.kind = 'contractData'
+                    effect.owner = emitted.owner
+                } else if (emitted.type.startsWith('contract')) {
+                    effect.kind = 'contractData'
+                    effect.owner = emitted.contract
+                } else
+                    throw new UnexpectedTxMetaChangeError({type: 'ttl', action: emitted.type})
+                emitted.ttl = ttl
+            }
         }
         this.addEffect(effect)
     }
@@ -1032,6 +1003,20 @@ class EffectsAnalyzer {
                 default:
                     throw new UnexpectedTxMetaChangeError(change)
             }
+        //ensure that the wasm upload effect always precedes contract creation effect
+        for (let i = 0; i < this.effects.length; i++) {
+            const effect = this.effects[i]
+            if (effect.type === effectTypes.contractCodeUploaded) {
+                //find the first reference in the already emitted effects
+                const createdFromCodeIdx = this.effects.findIndex(e => e.type === effectTypes.contractCreated && e.wasmHash === effect.wasmHash)
+                //reorder effects if needed
+                if (createdFromCodeIdx >= 0) {
+                    this.effects.splice(i, 1)
+                    this.effects.splice(createdFromCodeIdx, 0, effect)
+                    i--
+                }
+            }
+        }
     }
 
     processStateChanges() {
@@ -1048,8 +1033,17 @@ class EffectsAnalyzer {
     retrieveOpContractId() {
         const funcValue = this.operation.func._value._attributes
         if (funcValue) {
-            if (funcValue.contractAddress)
-                return StrKey.encodeContract(funcValue.contractAddress._value)
+            if (funcValue.contractAddress) {
+                let raw = funcValue.contractAddress._value
+                switch (raw._arm) {
+                    case 'ed25519':
+                        return StrKey.encodeContract(raw._value)
+                    case undefined:
+                        return StrKey.encodeContract(raw)
+                    default:
+                        throw new Error(`Unsupported contract address type: ${raw._arm}`)
+                }
+            }
             const preimage = funcValue.contractIdPreimage
             if (preimage)
                 return contractIdFromPreimage(preimage, this.network)

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

@@ -1,5 +1,5 @@
 const {StrKey} = require('@stellar/stellar-sdk')
-const {TxMetaEffectParserError, UnexpectedTxMetaChangeError} = require('../errors')
+const {TxMetaEffectParserError} = require('../errors')
 const {
     xdrParseAsset,
     xdrParseAccountAddress,
@@ -41,8 +41,6 @@ function parseLedgerEntryChanges(ledgerEntryChanges, filter = undefined) {
                 state = stateData
                 continue
             case 'created':
-                if (type === 'contractCode')
-                    continue //processed in operation handler
                 change.before = null
                 change.after = stateData
                 change.type = stateData.entry
@@ -59,8 +57,6 @@ function parseLedgerEntryChanges(ledgerEntryChanges, filter = undefined) {
                 state = change.after
                 break
             case 'removed':
-                if (!state && type === 'ttl')
-                    continue //skip expiration processing for now
                 change.before = state
                 change.after = null
                 change.type = state.entry
@@ -85,14 +81,14 @@ function parseEntry(entry, actionType) {
     if (actionType === 'removed')
         return null
     const value = entry.value()
-    const parsed = parseEntryData(value.data())
+    const parsed = parseEntryData(value.data(), actionType)
     if (parsed === null)
         return null
     //parsed.modified = entry.lastModifiedLedgerSeq()
     return parseLedgerEntryExt(parsed, value)
 }
 
-function parseEntryData(data) {
+function parseEntryData(data, actionType) {
     const updatedEntryType = data.arm()
     switch (updatedEntryType) {
         case 'account':
@@ -112,7 +108,7 @@ function parseEntryData(data) {
         case 'contractData':
             return parseContractData(data)
         case 'contractCode':
-            return parseContractCode(data)
+            return parseContractCode(data, actionType)
         case 'ttl':
             return parseTtl(data)
         default:
@@ -322,14 +318,18 @@ function parseStateOwnerDataAddress(contract) {
     return xdrParseAccountAddress(contract.accountId())
 }
 
-function parseContractCode(value) {
+function parseContractCode(value, actionType) {
     const contract = value.value()
     const hash = contract.hash()
-    return {
+    const res = {
         entry: 'contractCode',
         hash: hash.toString('hex'),
         keyHash: generateContractCodeEntryHash(hash)
     }
+    if (actionType === 'created') {
+        res.wasm = contract.code().toString('base64')
+    }
+    return res
 }
 
 module.exports = {parseLedgerEntryChanges}