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

package/package.json

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

package/src/{asset-supply-processor.js → aggregation/asset-supply-analyzer.js}

@@ -1,9 +1,9 @@
-const effectTypes = require('./effect-types')
+const effectTypes = require('../effect-types')
 
 /**
  * Effect supply computation processor
  */
-class AssetSupplyProcessor {
+class AssetSupplyAnalyzer {
     /**
      * @param {EffectsAnalyzer} effectsAnalyzer
      */
@@ -201,4 +201,4 @@ class CollapsibleMintsAnalyzer {
     }
 }
 
-module.exports = AssetSupplyProcessor
+module.exports = AssetSupplyAnalyzer

package/src/{events-analyzer.js → aggregation/events-analyzer.js}

@@ -1,7 +1,7 @@
 const {StrKey} = require('@stellar/stellar-base')
-const {xdrParseScVal, xdrParseAsset, isContractAddress, toStellarAsset} = require('./tx-xdr-parser-utils')
-const {contractIdFromAsset} = require('./contract-preimage-encoder')
-const effectTypes = require('./effect-types')
+const effectTypes = require('../effect-types')
+const {xdrParseScVal, xdrParseAsset, isContractAddress} = require('../parser/tx-xdr-parser-utils')
+const {mapSacContract} = require('./sac-contract-mapper')
 
 const EVENT_TYPES = {
     SYSTEM: 0,
@@ -10,8 +10,11 @@ const EVENT_TYPES = {
 }
 
 class EventsAnalyzer {
-    constructor(effectAnalyzer) {
-        this.effectAnalyzer = effectAnalyzer
+    /**
+     * @param {EffectsAnalyzer} effectsAnalyzer
+     */
+    constructor(effectsAnalyzer) {
+        this.effectsAnalyzer = effectsAnalyzer
         this.callStack = []
     }
 
@@ -30,7 +33,7 @@ class EventsAnalyzer {
      * @private
      */
     analyzeEvents() {
-        const {events} = this.effectAnalyzer
+        const {events} = this.effectsAnalyzer
         if (!events)
             return
         //contract-generated events
@@ -42,7 +45,7 @@ class EventsAnalyzer {
                 continue //skip data entries modifications
             const rawData = body.data()
             //add event to the pipeline
-            this.effectAnalyzer.addEffect({
+            this.effectsAnalyzer.addEffect({
                 type: effectTypes.contractEvent,
                 contract: StrKey.encodeContract(evt.contractId()),
                 topics,
@@ -58,7 +61,7 @@ class EventsAnalyzer {
      * @private
      */
     analyzeDiagnosticEvents() {
-        const {diagnosticEvents} = this.effectAnalyzer
+        const {diagnosticEvents} = this.effectsAnalyzer
         if (!diagnosticEvents)
             return
         //diagnostic events
@@ -81,9 +84,11 @@ class EventsAnalyzer {
     processDiagnosticEvent(body, type, contractId) {
         const topics = body.topics()
         if (!topics?.length)
-            return null
+            return
         switch (xdrParseScVal(topics[0])) {
             case 'fn_call': // contract call
+                if (type !== EVENT_TYPES.DIAGNOSTIC)
+                    return // skip non-diagnostic events
                 const rawArgs = body.data()
                 const parsedEvent = {
                     type: effectTypes.contractInvoked,
@@ -97,7 +102,7 @@ class EventsAnalyzer {
                     parsedEvent.depth = this.callStack.length
                 }
                 this.callStack.push(parsedEvent)
-                this.effectAnalyzer.addEffect(parsedEvent)
+                this.effectsAnalyzer.addEffect(parsedEvent)
                 break
             case 'fn_return':
                 if (type !== EVENT_TYPES.DIAGNOSTIC)
@@ -110,7 +115,7 @@ class EventsAnalyzer {
                 }
                 break
             //handle standard token contract events
-            //see https://github.com/stellar/rs-soroban-sdk/blob/71170fba76e1aa4d50224316f1157f0fb10e6d79/soroban-sdk/src/token.rs
+            //see https://github.com/stellar/rs-soroban-sdk/blob/main/soroban-sdk/src/token.rs
             case 'transfer': {
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     return
@@ -118,7 +123,6 @@ class EventsAnalyzer {
                 const to = xdrParseScVal(topics[2])
                 if (to === from) //self transfer - nothing happens
                     return // TODO: need additional checks
-                const sorobanAsset = contractId
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e =>
                     (e.function === 'transfer' && matchArrays([from, to, amount], e.args)) ||
@@ -128,31 +132,31 @@ class EventsAnalyzer {
                 let classicAsset
                 if (topics.length > 3) {
                     classicAsset = xdrParseAsset(xdrParseScVal(topics[3]))
-                    //validate
-                    if (contractIdFromAsset(toStellarAsset(classicAsset), this.effectAnalyzer.network) !== sorobanAsset)
-                        return //not an SAC transfer
+                    if (!mapSacContract(this.effectsAnalyzer, contractId, classicAsset)) {
+                        classicAsset = null  //not an SAC event
+                    }
                 }
                 if (classicAsset && (classicAsset.includes(from) || classicAsset.includes(to))) { //SAC transfer by asset issuer
                     if (classicAsset.includes(from)) {
-                        this.effectAnalyzer.mint(sorobanAsset, amount)
-                        this.effectAnalyzer.credit(amount, isContractAddress(to) ? sorobanAsset : classicAsset, to)
+                        this.effectsAnalyzer.mint(contractId, amount)
+                        this.effectsAnalyzer.credit(amount, isContractAddress(to) ? contractId : classicAsset, to)
                     }
                     if (classicAsset.includes(to)) {
-                        this.effectAnalyzer.debit(amount, isContractAddress(from) ? sorobanAsset : classicAsset, from)
-                        this.effectAnalyzer.burn(sorobanAsset, amount)
+                        this.effectsAnalyzer.debit(amount, isContractAddress(from) ? contractId : classicAsset, from)
+                        this.effectsAnalyzer.burn(contractId, amount)
                     }
                 } else { //other cases
                     if (classicAsset && !isContractAddress(from)) { //classic asset bridged to Soroban
-                        this.effectAnalyzer.burn(classicAsset, amount)
-                        this.effectAnalyzer.mint(sorobanAsset, amount)
+                        this.effectsAnalyzer.burn(classicAsset, amount)
+                        this.effectsAnalyzer.mint(contractId, amount)
                     } else {
-                        this.effectAnalyzer.debit(amount, sorobanAsset, from)
+                        this.effectsAnalyzer.debit(amount, contractId, from)
                     }
                     if (classicAsset && !isContractAddress(to)) { //classic asset bridged from Soroban
-                        this.effectAnalyzer.burn(sorobanAsset, amount)
-                        this.effectAnalyzer.mint(classicAsset, amount)
+                        this.effectsAnalyzer.burn(contractId, amount)
+                        this.effectsAnalyzer.mint(classicAsset, amount)
                     } else {
-                        this.effectAnalyzer.credit(amount, sorobanAsset, to)
+                        this.effectsAnalyzer.credit(amount, contractId, to)
                     }
                 }
 
@@ -165,12 +169,15 @@ class EventsAnalyzer {
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'mint' && matchArrays([to, amount], e.args)))
                     return
-                this.effectAnalyzer.addEffect({
+                this.effectsAnalyzer.addEffect({
                     type: effectTypes.assetMinted,
                     asset: contractId,
                     amount
                 })
-                this.effectAnalyzer.credit(amount, contractId, to)
+                this.effectsAnalyzer.credit(amount, contractId, to)
+                if (topics.length > 3) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[3])))
+                }
             }
                 break
             case 'burn': {
@@ -184,8 +191,11 @@ class EventsAnalyzer {
                 ))
                     return
 
-                this.effectAnalyzer.debit(amount, contractId, from)
-                this.effectAnalyzer.burn(contractId, amount)
+                this.effectsAnalyzer.debit(amount, contractId, from)
+                this.effectsAnalyzer.burn(contractId, amount)
+                if (topics.length > 2) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[2])))
+                }
             }
                 break
             case 'clawback': {
@@ -195,46 +205,41 @@ class EventsAnalyzer {
                 const amount = processEventBodyValue(body.data())
                 if (!this.matchInvocationEffect(e => e.function === 'clawback' && matchArrays([from, amount], e.args)))
                     return
-                this.effectAnalyzer.debit(amount, contractId, from)
-                this.effectAnalyzer.burn(contractId, amount)
+                this.effectsAnalyzer.debit(amount, contractId, from)
+                this.effectsAnalyzer.burn(contractId, amount)
+                if (topics.length > 3) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[3])))
+                }
             }
                 break
-            //TODO: process token allowance, authorization approval, and admin modification for SAC contracts
-            /*case 'approve': {
+            case 'set_admin': {
+                if (!matchEventTopicsShape(topics, ['address', 'str?']))
+                    return //throw new Error('Non-standard event')
+                const currentAdmin = xdrParseScVal(topics[1])
+                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(contractId, newAdmin)
+                if (topics.length > 2) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[2])))
+                }
+            }
+                break
+            /*case 'approve': { //TODO: think about processing this effect
                 if (!matchEventTopicsShape(topics, ['address', 'address', 'str?']))
                     throw new Error('Non-standard event')
                 const from = xdrParseScVal(topics[1])
                 const spender = xdrParseScVal(topics[2])
-            }
-                break
-
-            case 'set_authorized': {
-                throw new Error('Not implemented')
-                //trustlineAuthorizationUpdated
-                if (!matchEventTopicsShape(topics, ['address', 'address', 'bool', 'str?']))
-                    throw new Error('Non-standard event')
-                const admin = xdrParseScVal(topics[1])
-                const id = xdrParseScVal(topics[2])
-                const authorize = xdrParseScVal(topics[3])
-            }
-                break
-            case 'set_admin': {
-                throw new Error('Not implemented')
-                if (!matchEventTopicsShape(topics, ['address']))
-                    throw new Error('Non-standard event')
-                const prevAdmin = xdrParseScVal(topics[1])
-                const newAdmin = processEventBodyValue(topics[2])
+                if (topics.length > 3) {
+                    mapSacContract(this.effectsAnalyzer, contractId, xdrParseAsset(xdrParseScVal(topics[3])))
+                }
             }
                 break*/
-            default:
-                //console.log(`Event ` + xdrParseScVal(topics[0]))
-                break
         }
-        return null
     }
 
     matchInvocationEffect(cb) {
-        return this.effectAnalyzer.effects.find(e => e.type === effectTypes.contractInvoked && cb(e))
+        return this.effectsAnalyzer.effects.find(e => e.type === effectTypes.contractInvoked && cb(e))
     }
 }
 

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

@@ -0,0 +1,40 @@
+const TtlCache = require('../cache/ttl-cache')
+const {toStellarAsset} = require('../parser/tx-xdr-parser-utils')
+const {contractIdFromAsset} = require('../parser/contract-preimage-encoder')
+
+const sacCache = new TtlCache()
+
+/**
+ * Check and map SAC contract addresses with Classic assets
+ * @param {EffectsAnalyzer} effectsAnalyzer
+ * @param {String} contractAddress
+ * @param {String} classicAsset
+ * @return {Boolean}
+ */
+function mapSacContract(effectsAnalyzer, contractAddress, classicAsset) {
+    if (!classicAsset)
+        return false
+    const {network, sacMap} = effectsAnalyzer
+    //try to load from cache first
+    const fromCache = sacCache.get(contractAddress + network)
+    if (!fromCache) {
+        const encodedContract = contractIdFromAsset(toStellarAsset(classicAsset), network)
+        sacCache.set(encodedContract + network, classicAsset)
+        if (encodedContract !== contractAddress)
+            return false
+    } else if (classicAsset !== fromCache)
+        return false //check whether validated contract from cache matches the asset
+    if (sacMap) {
+        sacMap[contractAddress] = classicAsset
+    }
+    return true
+}
+
+/**
+ * Dispose SAC cache mapping and release cleanup timers
+ */
+function disposeSacCache() {
+    sacCache.dispose()
+}
+
+module.exports = {mapSacContract, disposeSacCache}

package/src/{signer-changes-analyzer.js → aggregation/signer-changes-analyzer.js}

@@ -1,4 +1,4 @@
-const effectTypes = require('./effect-types')
+const effectTypes = require('../effect-types')
 
 class SignerChangesAnalyzer {
     constructor(before, after) {

package/src/cache/ttl-cache.js

@@ -0,0 +1,82 @@
+class TtlCache {
+    /**
+     * Create new instance of ClientCache with simple in-memory storage
+     * @param {Number} ttl - Uniform time-to-live (in seconds)
+     */
+    constructor(ttl = 2 * 60) {
+        this.ttl = ttl * 1000
+        this.storage = new Map()
+    }
+
+    /**
+     * @type {Number}
+     */
+    ttl
+    /**
+     * @type {Map<String,{ts:Number,value:*}>}
+     * @private
+     */
+    storage
+    /**
+     * @type {Number}
+     * @private
+     */
+    scheduledCleanup = 0
+
+    /**
+     * Try to retrieve an item from the cache
+     * @param {String} key
+     * @return {*}
+     */
+    get(key) {
+        let item = this.storage.get(key)
+        if (!item)
+            return null
+        item.ts = new Date().getTime()
+        return item.value
+    }
+
+    /**
+     * Add/replace cache object
+     * @param {String} key - Unique key
+     * @param {*} value - Associated value to store
+     */
+    set(key, value) {
+        this.storage.set(key, {value, ts: new Date().getTime()})
+        this.scheduleCleanup()
+    }
+
+    /**
+     * @private
+     */
+    cleanupApiCache() {
+        const {storage, ttl} = this
+        const expired = new Date().getTime() - ttl
+        for (const [key, item] of storage.entries()) {
+            if (item.ts < expired) {
+                storage.delete(key)
+            }
+        }
+        this.scheduledCleanup = 0
+        this.scheduleCleanup()
+    }
+
+    /**
+     * @private
+     */
+    scheduleCleanup() {
+        if (!this.scheduledCleanup && this.storage.size > 0) { //schedule new cleanup if storage is not empty
+            this.scheduledCleanup = setTimeout(() => this.cleanupApiCache(), this.ttl + 10)
+        }
+    }
+
+    /**
+     * Stop scheduled cleanup task and free resources
+     */
+    dispose() {
+        clearTimeout(this.scheduledCleanup)
+        this.storage = null
+    }
+}
+
+module.exports = TtlCache

package/src/{tx-effects-analyzer.js → effects-analyzer.js}

@@ -1,16 +1,15 @@
 const {StrKey, hash, xdr, nativeToScVal} = require('@stellar/stellar-base')
 const effectTypes = require('./effect-types')
-const {parseLedgerEntryChanges} = require('./ledger-entry-changes-parser')
-const {xdrParseAsset, xdrParseAccountAddress, xdrParseScVal} = require('./tx-xdr-parser-utils')
-const {encodeSponsorshipEffectName} = require('./analyzer-primitives')
-const {analyzeSignerChanges} = require('./signer-changes-analyzer')
-const {contractIdFromPreimage} = require('./contract-preimage-encoder')
-const EventsAnalyzer = require('./events-analyzer')
-const AssetSupplyProcessor = require('./asset-supply-processor')
+const {parseLedgerEntryChanges} = require('./parser/ledger-entry-changes-parser')
+const {xdrParseAsset, xdrParseAccountAddress, xdrParseScVal} = require('./parser/tx-xdr-parser-utils')
+const {analyzeSignerChanges} = require('./aggregation/signer-changes-analyzer')
+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')
 
 class EffectsAnalyzer {
-    constructor({operation, meta, result, network, events, diagnosticEvents}) {
+    constructor({operation, meta, result, network, events, diagnosticEvents, mapSac}) {
         //set execution context
         if (!operation.source)
             throw new TxMetaEffectParserError('Operation source is not explicitly defined')
@@ -24,6 +23,9 @@ class EffectsAnalyzer {
             this.diagnosticEvents = diagnosticEvents
         }
         this.network = network
+        if (mapSac) {
+            this.sacMap = {}
+        }
     }
 
     /**
@@ -43,6 +45,11 @@ class EffectsAnalyzer {
      * @readonly
      */
     network
+    /**
+     * @type {{}}
+     * @readonly
+     */
+    sacMap
     /**
      * @type {ParsedLedgerEntryMeta[]}
      * @private
@@ -68,7 +75,7 @@ class EffectsAnalyzer {
     isContractCall = false
 
     analyze() {
-        //find appropriate parsing method
+        //find appropriate parser method
         const parse = this[this.operation.type]
         if (parse) {
             parse.call(this)
@@ -80,7 +87,7 @@ class EffectsAnalyzer {
         //process Soroban events
         new EventsAnalyzer(this).analyze()
         //calculate minted/burned assets
-        new AssetSupplyProcessor(this).analyze()
+        new AssetSupplyAnalyzer(this).analyze()
         //process state data changes in the end
         for (const change of this.changes)
             if (change.type === 'contractData') {
@@ -368,6 +375,15 @@ class EffectsAnalyzer {
     restoreFootprint() {
     }
 
+    setAdmin(contractId, newAdmin) {
+        const effect = {
+            type: effectTypes.contractUpdated,
+            contract: contractId,
+            admin: newAdmin
+        }
+        this.addEffect(effect)
+    }
+
     processDexOperationEffects() {
         //process trades first
         for (const claimedOffer of this.result.claimedOffers) {
@@ -897,4 +913,28 @@ function normalizeAddress(address) {
     return StrKey.encodeEd25519PublicKey(rawBytes.subarray(0, 32))
 }
 
+
+/**
+ * @param {String} action
+ * @param {String} type
+ * @return {String}
+ */
+function encodeSponsorshipEffectName(action, type) {
+    let actionKey
+    switch (action) {
+        case 'created':
+            actionKey = 'Created'
+            break
+        case 'updated':
+            actionKey = 'Updated'
+            break
+        case 'removed':
+            actionKey = 'Removed'
+            break
+        default:
+            throw new UnexpectedTxMetaChangeError({action, type})
+    }
+    return effectTypes[`${type}Sponsorship${actionKey}`]
+}
+
 module.exports = {EffectsAnalyzer, processFeeChargedEffect}

package/src/index.js

@@ -1,23 +1,25 @@
 const {TransactionBuilder, xdr} = require('@stellar/stellar-base')
-const {processFeeChargedEffect, analyzeOperationEffects, EffectsAnalyzer} = require('./tx-effects-analyzer')
-const {parseTxResult} = require('./tx-result-parser')
-const {parseLedgerEntryChanges} = require('./ledger-entry-changes-parser')
-const {parseTxMetaChanges} = require('./tx-meta-changes-parser')
-const {analyzeSignerChanges} = require('./signer-changes-analyzer')
-const contractPreimageEncoder = require('./contract-preimage-encoder')
-const xdrParserUtils = require('./tx-xdr-parser-utils')
-const effectTypes = require('./effect-types')
 const {TxMetaEffectParserError, UnexpectedTxMetaChangeError} = require('./errors')
+const {processFeeChargedEffect, analyzeOperationEffects, EffectsAnalyzer} = require('./effects-analyzer')
+const {disposeSacCache} = require('./aggregation/sac-contract-mapper')
+const {parseTxResult} = require('./parser/tx-result-parser')
+const {parseLedgerEntryChanges} = require('./parser/ledger-entry-changes-parser')
+const {parseTxMetaChanges} = require('./parser/tx-meta-changes-parser')
+const {analyzeSignerChanges} = require('./aggregation/signer-changes-analyzer')
+const contractPreimageEncoder = require('./parser/contract-preimage-encoder')
+const xdrParserUtils = require('./parser/tx-xdr-parser-utils')
+const effectTypes = require('./effect-types')
 
 /**
  * Retrieve effects from transaction execution result metadata
  * @param {String} network - Network passphrase
  * @param {String|Buffer|xdr.TransactionEnvelope} tx - Base64-encoded tx envelope xdr
- * @param {String|Buffer|xdr.TransactionResult} result? - Base64-encoded tx envelope result
- * @param {String|Buffer|xdr.TransactionMeta} meta? - Base64-encoded tx envelope meta
+ * @param {String|Buffer|xdr.TransactionResult} [result] - Base64-encoded tx envelope result
+ * @param {String|Buffer|xdr.TransactionMeta} [meta] - Base64-encoded tx envelope meta
+ * @param {Boolean} [mapSac] - Whether to create a map SAC->Asset
  * @return {ParsedTxOperationsMetadata}
  */
-function parseTxOperationsMeta({network, tx, result, meta}) {
+function parseTxOperationsMeta({network, tx, result, meta, mapSac = false}) {
     if (!network)
         throw new TypeError(`Network passphrase argument is required.`)
     if (typeof network !== 'string')
@@ -135,9 +137,13 @@ function parseTxOperationsMeta({network, tx, result, meta}) {
                 const sorobanMeta = metaValue.sorobanMeta()
                 params.events = sorobanMeta.events()
                 params.diagnosticEvents = sorobanMeta.diagnosticEvents()
+                params.mapSac = mapSac
             }
             const analyzer = new EffectsAnalyzer(params)
             operation.effects = analyzer.analyze()
+            if (analyzer.sacMap && !isEmptyObject(analyzer.sacMap)) {
+                operation.sacMap = analyzer.sacMap
+            }
         }
     }
     return res
@@ -159,13 +165,20 @@ function ensureXdrInputType(value, xdrType) {
     return xdrType.fromXDR(value, typeof value === 'string' ? 'base64' : 'raw')
 }
 
+function isEmptyObject(obj) {
+    for (const key in obj)
+        return false
+    return true
+}
+
 /**
  * @typedef {{}} ParsedTxOperationsMetadata
- * @property {Transaction|FeeBumpTransaction} tx
- * @property {BaseOperation[]} operations
- * @property {Boolean} isEphemeral
- * @property {Boolean} [failed]
- * @property {{}[]} [effects]
+ * @property {Transaction|FeeBumpTransaction} tx - Parsed transaction object
+ * @property {BaseOperation[]} operations - Transaction operations
+ * @property {Boolean} isEphemeral - True for transactions without result metadata
+ * @property {Boolean} [failed] - True for transactions failed during on-chain execution
+ * @property {{}[]} [effects] - Top-level transaction effects (fee charges and )
+ * @property {Object<String,String>} [sacMap] - Optional map of SAC->Asset
  */
 
 module.exports = {
@@ -176,5 +189,6 @@ module.exports = {
     parseTxMetaChanges,
     effectTypes,
     xdrParserUtils,
-    contractPreimageEncoder
+    contractPreimageEncoder,
+    disposeSacCache
 }

package/src/{ledger-entry-changes-parser.js → parser/ledger-entry-changes-parser.js}

@@ -1,13 +1,6 @@
 const {StrKey} = require('@stellar/stellar-base')
-const {
-    xdrParseAsset,
-    xdrParseAccountAddress,
-    xdrParseClaimant,
-    xdrParsePrice,
-    xdrParseSignerKey,
-    xdrParseScVal
-} = require('./tx-xdr-parser-utils')
-const {TxMetaEffectParserError} = require('./errors')
+const {TxMetaEffectParserError} = require('../errors')
+const {xdrParseAsset, xdrParseAccountAddress, xdrParseClaimant, xdrParsePrice, xdrParseSignerKey} = require('./tx-xdr-parser-utils')
 
 /**
  * @typedef {{}} ParsedLedgerEntryMeta

package/src/{tx-meta-changes-parser.js → parser/tx-meta-changes-parser.js}

@@ -1,5 +1,5 @@
 const {parseLedgerEntryChanges} = require('./ledger-entry-changes-parser')
-const {TxMetaEffectParserError} = require('./errors')
+const {TxMetaEffectParserError} = require('../errors')
 
 /**
  * Parse top-level transaction metadata changes

package/src/{tx-result-parser.js → parser/tx-result-parser.js}

@@ -1,6 +1,6 @@
 const {xdr} = require('@stellar/stellar-base')
 const {xdrParseAccountAddress, xdrParseTradeAtom, xdrParseClaimedOffer, xdrParseAsset} = require('./tx-xdr-parser-utils')
-const {TxMetaEffectParserError} = require('./errors')
+const {TxMetaEffectParserError} = require('../errors')
 
 /**
  * Parse extra data from operation result

package/src/{tx-xdr-parser-utils.js → parser/tx-xdr-parser-utils.js}

@@ -1,5 +1,5 @@
 const {StrKey, LiquidityPoolId, scValToBigInt, xdr, Asset} = require('@stellar/stellar-base')
-const {TxMetaEffectParserError} = require('./errors')
+const {TxMetaEffectParserError} = require('../errors')
 
 /**
  * @param {String} address

package/src/analyzer-primitives.js

@@ -1,150 +0,0 @@
-const {StrKey} = require('@stellar/stellar-base')
-const effectTypes = require('./effect-types')
-const {UnexpectedTxMetaChangeError} = require('./errors')
-
-/**
- * Returns true for AlphaNum4/12 assets adn false otherwise
- * @param {String} asset
- */
-function isAsset(asset) {
-    return asset.includes('-') //lazy check for {code}-{issuer}-{type} format
-}
-
-
-/**
- * Convert value in stroops (Int64 amount) to the normal string representation
- * @param {String|Number|BigInt} valueInStroops
- * @return {String}
- */
-function fromStroops(valueInStroops) {
-    try {
-        let parsed = typeof valueInStroops === 'bigint' ?
-            valueInStroops :
-            BigInt(valueInStroops.toString())
-        let negative = false
-        if (parsed < 0n) {
-            negative = true
-            parsed *= -1n
-        }
-        const int = parsed / 10000000n
-        const fract = parsed % 10000000n
-        let res = int.toString()
-        if (fract) {
-            res += '.' + fract.toString().padStart(7, '0')
-        }
-        if (negative) {
-            res = '-' + res
-        }
-        return trimZeros(res)
-    } catch (e) {
-        return '0'
-    }
-}
-
-
-/**
- * Convert arbitrary stringified amount to int64 representation
- * @param {String|Number} value
- * @return {BigInt}
- */
-function toStroops(value) {
-    if (!value)
-        return 0n
-    if (typeof value === 'number') {
-        value = value.toFixed(7)
-    }
-    if (typeof value !== 'string' || !/^-?[\d.,]+$/.test(value))
-        return 0n //invalid format
-    try {
-        let [int, decimal = '0'] = value.split('.', 2)
-        let negative = false
-        if (int.startsWith('-')) {
-            negative = true
-            int = int.slice(1)
-        }
-        let res = BigInt(int) * 10000000n + BigInt(decimal.slice(0, 7).padEnd(7, '0'))
-        if (negative) {
-            res *= -1n
-            if (res < -0x8000000000000000n) //overflow
-                return 0n
-        } else if (res > 0xFFFFFFFFFFFFFFFFn) //overflow
-            return 0n
-        return res
-    } catch (e) {
-        return 0n
-    }
-}
-
-/**
- * Trim trailing fractional zeros from a string amount representation
- * @param {String} value
- * @return {String}
- * @internal
- */
-function trimZeros(value) {
-    const [int, fract] = value.split('.')
-    if (!fract)
-        return int
-    const trimmed = fract.replace(/0+$/, '')
-    if (!trimmed.length)
-        return int
-    return int + '.' + trimmed
-}
-
-/**
- * Replace multiplexed addresses with base G addresses
- * @param {String} address
- * @return {String}
- * @internal
- */
-function normalizeAddress(address) {
-    const prefix = address[0]
-    if (prefix === 'G')
-        return address //lazy check for ed25519 G address
-    if (prefix !== 'M')
-        throw new TypeError('Expected ED25519 or Muxed address')
-    const rawBytes = StrKey.decodeMed25519PublicKey(address)
-    return StrKey.encodeEd25519PublicKey(rawBytes.subarray(0, 32))
-}
-
-/**
- * @param {String} action
- * @param {String} type
- * @return {String}
- */
-function encodeSponsorshipEffectName(action, type) {
-    let actionKey
-    switch (action) {
-        case 'created':
-            actionKey = 'Created'
-            break
-        case 'updated':
-            actionKey = 'Updated'
-            break
-        case 'removed':
-            actionKey = 'Removed'
-            break
-        default:
-            throw new UnexpectedTxMetaChangeError({action, type})
-    }
-    return effectTypes[`${type}Sponsorship${actionKey}`]
-}
-
-/**
- * Check if asset issuer is a source account
- * @param {String} account
- * @param {String} asset
- * @return {Boolean}
- */
-function isIssuer(account, asset) {
-    return asset.includes(account)
-}
-
-module.exports = {
-    fromStroops,
-    toStroops,
-    normalizeAddress,
-    encodeSponsorshipEffectName,
-    isIssuer,
-    isAsset
-}

package/src/effect.js

@@ -1,24 +0,0 @@
-class Effect {
-    constructor(type, source) {
-    }
-
-    /**
-     * @type {String}
-     * @readonly
-     */
-    type
-
-    /**
-     * @type {String}
-     * @readonly
-     */
-    source
-
-    toString() {
-        return this.toJSON()
-    }
-
-    toJSON() {
-
-    }
-}