@stellar-expert/tx-meta-effects-parser 5.0.0-beta10

package/src/tx-meta-changes-parser.js

@@ -0,0 +1,35 @@
+const {parseLedgerEntryChanges} = require('./ledger-entry-changes-parser')
+const {TxMetaEffectParserError} = require('./errors')
+
+/**
+ * Parse top-level transaction metadata changes
+ * @param {TransactionMeta} meta
+ * @return {ParsedLedgerEntryMeta[]}
+ */
+function parseTxMetaChanges(meta) {
+    const transactionMeta = meta.value()
+    const txMetaChanges = []
+
+    switch (meta.arm()) {
+        case 'v1':
+            retrieveTopLevelChanges(transactionMeta.txChanges(), txMetaChanges)
+            break
+        case 'v2':
+        case 'v3':
+            retrieveTopLevelChanges(transactionMeta.txChangesBefore(), txMetaChanges)
+            retrieveTopLevelChanges(transactionMeta.txChangesAfter(), txMetaChanges)
+            break
+        default:
+            throw new TxMetaEffectParserError(`Transaction meta version ${meta.arm()} is not supported.`)
+    }
+
+    return txMetaChanges
+}
+
+function retrieveTopLevelChanges(changes, res) {
+    for (const entry of parseLedgerEntryChanges(changes)) {
+        res.push(entry)
+    }
+}
+
+module.exports = {parseTxMetaChanges}

package/src/tx-result-parser.js

@@ -0,0 +1,127 @@
+const {xdr} = require('@stellar/stellar-base')
+const {xdrParseAccountAddress, xdrParseTradeAtom, xdrParseClaimedOffer, xdrParseAsset} = require('./tx-xdr-parser-utils')
+const {TxMetaEffectParserError} = require('./errors')
+
+/**
+ * Parse extra data from operation result
+ * @param {Object} rawOpResult - Operation result XDR
+ * @return {Object}
+ */
+function parseRawOpResult(rawOpResult) {
+    const inner = rawOpResult.tr()
+    if (inner === undefined)
+        return null //"opNoAccount" Case
+    const opResult = inner.value()
+    const successOpResultType = opResult.switch()
+
+    //no need to parse failed operations
+    if (successOpResultType.value < 0)
+        return null
+
+    const res = {
+        resultType: successOpResultType.name
+    }
+
+    switch (successOpResultType.name) {
+        case 'pathPaymentStrictReceiveSuccess':
+        case 'pathPaymentStrictSendSuccess': {
+            res.claimedOffers = opResult.value().offers().map(claimedOffer => xdrParseClaimedOffer(claimedOffer))
+            const paymentValue = opResult.value().last()
+            res.payment = {
+                account: xdrParseAccountAddress(paymentValue.destination()),
+                amount: paymentValue.amount().toString(),
+                asset: xdrParseAsset(paymentValue.asset())
+            }
+        }
+            break
+        case 'manageSellOfferSuccess':
+        case 'manageBuyOfferSuccess': {
+            const makerOfferXdr = opResult.value().offer().value()
+            res.makerOffer = makerOfferXdr && xdrParseTradeAtom(makerOfferXdr)
+            res.claimedOffers = opResult.value().offersClaimed().map(claimedOffer => xdrParseClaimedOffer(claimedOffer))
+        }
+            break
+        case 'accountMergeSuccess':
+            //retrieve the actual amount of transferred XLM
+            res.actualMergedAmount = opResult.sourceAccountBalance().toString()
+            break
+        case 'inflationSuccess':
+            res.inflationPayouts = (opResult.payouts() || []).map(payout => ({
+                account: xdrParseAccountAddress(payout.destination()),
+                amount: payout.amount().toString()
+            }))
+            break
+        case 'createClaimableBalanceSuccess':
+            res.balanceId = Buffer.from(opResult.balanceId().value()).toString('hex')
+            break
+        case 'invokeHostFunctionSuccess':
+            res.result = opResult.value()
+            break
+        case 'setOptionsSuccess':
+        case 'manageDataSuccess':
+        case 'createAccountSuccess':
+        case 'paymentSuccess':
+        case 'changeTrustSuccess':
+        case 'allowTrustSuccess':
+        case 'bumpSequenceSuccess':
+        case 'claimClaimableBalanceSuccess':
+        case 'beginSponsoringFutureReservesSuccess':
+        case 'endSponsoringFutureReservesSuccess':
+        case 'revokeSponsorshipSuccess':
+        case 'clawbackSuccess':
+        case 'clawbackClaimableBalanceSuccess':
+        case 'setTrustLineFlagsSuccess':
+        case 'liquidityPoolDepositSuccess':
+        case 'liquidityPoolWithdrawSuccess':
+        case 'restoreFootprintSuccess':
+        case 'extendFootprintTtlSuccess':
+            break //no extra info available
+        default:
+            throw new TxMetaEffectParserError(`Unknown op result: ${successOpResultType.name}`)
+    }
+    return res
+}
+
+/**
+ * @typedef {Object} ParsedTxResult
+ * @property {Object} feeCharged
+ * @property {Boolean} success
+ * @property {Array<Object>} opResults
+ */
+
+/**
+ * Parse single transaction result.
+ * @param {Object|String} result - Raw transaction result XDR.
+ * @return {ParsedTxResult}
+ */
+function parseTxResult(result) {
+    if (typeof result === 'string') {
+        result = xdr.TransactionResult.fromXDR(result, 'base64')
+    }
+    const innerResult = result.result()
+    const txResultState = innerResult.switch()
+    const feeCharged = result.feeCharged().toString()
+    const success = txResultState.value >= 0
+
+    let opResults = []
+    if (success) {
+        switch (txResultState.name) {
+            case 'txFeeBumpInnerSuccess':
+                //const childTxHash = innerResult.innerResultPair().transactionHash()
+                opResults = (innerResult.value().result().result().results() || []).map(parseRawOpResult)
+                break
+            case 'txSuccess':
+                opResults = (innerResult.results() || []).map(parseRawOpResult)
+                break
+            default:
+                throw new TxMetaEffectParserError(`Invalid tx result state switch: ${txResultState.name}`)
+        }
+    }
+    return {
+        success,
+        opResults,
+        feeCharged
+    }
+}
+
+module.exports = {parseTxResult}

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

@@ -0,0 +1,276 @@
+const {StrKey, LiquidityPoolId, scValToBigInt, xdr} = require('@stellar/stellar-base')
+const {TxMetaEffectParserError} = require('./errors')
+
+/**
+ * Parse account address from XDR representation
+ * @param accountId
+ * @param muxedAccountsSupported
+ * @return {String|{muxedId: String, primary: String}}
+ */
+function xdrParseAccountAddress(accountId, muxedAccountsSupported = false) {
+    if (!accountId)
+        return undefined
+    if (accountId.arm) {
+        switch (accountId.arm()) {
+            case 'ed25519':
+                return StrKey.encodeEd25519PublicKey(accountId.ed25519())
+            case 'med25519':
+                if (!muxedAccountsSupported)
+                    throw new TxMetaEffectParserError(`Muxed accounts not supported here`)
+                return {
+                    primary: StrKey.encodeEd25519PublicKey(accountId.value().ed25519()),
+                    muxedId: accountId.value().id().toString()
+                }
+            default:
+                throw new TxMetaEffectParserError(`Unsupported account type: ${accountId.arm()}`)
+        }
+    }
+    if (accountId instanceof Buffer) {
+        return StrKey.encodeEd25519PublicKey(accountId)
+    }
+    throw new TypeError(`Failed to identify and parse account address: ${accountId}`)
+}
+
+/**
+ * Parse Contract ID from raw bytes
+ * @param {Buffer} rawContractId
+ * @return {String}
+ */
+function xdrParseContractAddress(rawContractId) {
+    return StrKey.encodeContract(rawContractId)
+}
+
+/**
+ * Parse XDR price representation
+ * @param {{n: Function, d: Function}} price
+ * @return {Number}
+ */
+function xdrParsePrice(price) {
+    return price.n() / price.d()
+}
+
+/**
+ * Parse account signer key XDR
+ * @param {xdr.SignerKey} signer
+ * @return {String}
+ */
+function xdrParseSignerKey(signer) {
+    const type = signer.arm()
+    switch (type) {
+        case 'ed25519':
+            return StrKey.encodeEd25519PublicKey(signer.ed25519())
+        case 'preAuthTx':
+            return StrKey.encodePreAuthTx(signer.preAuthTx())
+        case 'hashX':
+            return StrKey.encodeSha256Hash(signer.hashX())
+        case 'ed25519SignedPayload':
+            return StrKey.encodeSignedPayload(signer.ed25519SignedPayload()) //TODO: check
+    }
+    throw new TxMetaEffectParserError(`Unsupported signer type: "${type}"`)
+}
+
+
+/**
+ * @typedef {Object} ParsedOffer
+ * @property {String} account
+ * @property {Array<String>} asset
+ * @property {Array<String>} amount
+ * @property {String} offerId?
+ * @property {Buffer} poolId?
+ */
+
+/**
+ * Parse maker offer descriptor from raw XDR.
+ * @param {Object} offerXdr
+ * @return {ParsedOffer}
+ */
+function xdrParseTradeAtom(offerXdr) {
+    return {
+        offerId: offerXdr.offerId().toString(),
+        account: xdrParseAccountAddress(offerXdr.sellerId()),
+        asset: [xdrParseAsset(offerXdr.selling()).toString(), xdrParseAsset(offerXdr.buying()).toString()],
+        //offer amount is always stored in terms of a selling asset, even for buy offers
+        amount: (offerXdr.amount() || offerXdr.buyAmount()).toString(),
+        //flags: offerXdr.flags()
+        price: xdrParsePrice(offerXdr.price())
+    }
+}
+
+/**
+ * Parse claimed offer atom from raw XDR.
+ * @param {xdr.ClaimAtom} claimedAtom
+ * @return {ParsedOffer}
+ */
+function xdrParseClaimedOffer(claimedAtom) {
+    const atomType = claimedAtom.arm()
+    let res
+    switch (atomType) {
+        case 'v0':
+            claimedAtom = claimedAtom.v0()
+            res = {
+                account: xdrParseAccountAddress(claimedAtom.sellerEd25519()),
+                offerId: claimedAtom.offerId().toString()
+            }
+            break
+        case 'orderBook':
+            claimedAtom = claimedAtom.orderBook()
+            res = {
+                account: xdrParseAccountAddress(claimedAtom.sellerId()),
+                offerId: claimedAtom.offerId().toString()
+            }
+            break
+        case 'liquidityPool':
+            claimedAtom = claimedAtom.liquidityPool()
+            res = {
+                poolId: claimedAtom.liquidityPoolId()
+            }
+            break
+        default:
+            throw new TxMetaEffectParserError(`Unsupported claimed atom type: ` + atomType)
+    }
+    return {
+        asset: [
+            xdrParseAsset(claimedAtom.assetSold()),
+            xdrParseAsset(claimedAtom.assetBought())
+        ],
+        amount: [
+            claimedAtom.amountSold().toString(),
+            claimedAtom.amountBought().toString()
+        ],
+        ...res
+    }
+}
+
+function xdrParseClaimantPredicate(predicate) {
+    if (!predicate) return {}
+    const type = predicate.switch().name
+    const value = predicate.value()
+    switch (type) {
+        case 'claimPredicateUnconditional':
+            return {}
+        case 'claimPredicateAnd':
+            return {and: value.map(p => xdrParseClaimantPredicate(p))}
+        case 'claimPredicateOr':
+            return {or: value.map(p => xdrParseClaimantPredicate(p))}
+        case 'claimPredicateNot':
+            return {not: xdrParseClaimantPredicate(value)}
+        case 'claimPredicateBeforeAbsoluteTime':
+            return {absBefore: value.toString()}
+        case 'claimPredicateBeforeRelativeTime':
+            return {relBefore: value.toString()}
+        default:
+            throw new TxMetaEffectParserError(`Unknown claim condition predicate: ${type}`)
+    }
+}
+
+function xdrParseClaimant(claimant) {
+    const value = claimant.value()
+    return {
+        destination: xdrParseAccountAddress(value.destination()),
+        predicate: xdrParseClaimantPredicate(value.predicate())
+    }
+}
+
+function xdrParseAsset(src) {
+    if (!src)
+        return undefined
+
+    if (src.arm) { //XDR
+        switch (src.switch().name) {
+            case 'assetTypeNative':
+                return 'XLM'
+            case 'assetTypePoolShare': {
+                const poolId = src.value()
+                if (poolId.length)
+                    return poolId.toString('hex')
+                if (poolId.constantProduct)
+                    return LiquidityPoolId.fromOperation(poolId).getLiquidityPoolId()
+                throw new TxMetaEffectParserError('Unsupported liquidity pool asset id format')
+            }
+            default: {
+                const value = src.value()
+                return `${value.assetCode().toString().replace(/\0+$/, '')}-${StrKey.encodeEd25519PublicKey(value.issuer().ed25519())}-${src.arm() === 'alphaNum4' ? 1 : 2}`
+            }
+        }
+    }
+
+    if (typeof src === 'string') {
+        if (src === 'XLM' || src === 'native' || src.includes('-'))
+            return 'XLM'//already parsed value
+        if (src.includes(':')) {
+            const [code, issuer] = src.split(':')
+            return `${code.replace(/\0+$/, '')}-${issuer}-${code.length > 4 ? 2 : 1}`
+        }
+        if (src.length === 64)
+            return src //pool id
+    }
+    if (src.type === 0 && !src.code || src.code === 'XLM' && !src.issuer)
+        return 'XLM'
+    if (src.code && src.issuer)
+        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')
+    }
+    switch (value._arm) {
+        case 'vec':
+            return value._value.map(xdrParseScVal)
+        case 'map':
+            const res = {}
+            for (const entry of value._value) {
+                res[xdrParseScVal(entry.key())] = xdrParseScVal(entry.val())
+            }
+            return res
+        case 'i256':
+        case 'u256':
+        case 'i128':
+        case 'u128':
+        case 'i64':
+        case 'u64':
+        case 'timepoint':
+        case 'duration':
+            return scValToBigInt(value).toString()
+        case 'address':
+            if (value._value._arm === 'accountId')
+                return xdrParseAccountAddress(value._value.value())
+            if (value._value._arm === 'contractId')
+                return xdrParseContractAddress(value._value.value())
+            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value.toString())
+        case 'bytes':
+            return treatBytesAsContractId ? xdrParseContractAddress(value.value()) : value._value.toString('base64')
+        case 'i32':
+        case 'u32':
+        case 'b':
+            return value._value
+        case 'str':
+        case 'sym':
+            return value._value.toString()
+        case 'nonceKey':
+            return value._value.nonce()._value.toString()
+        case 'instance':
+            return value._value.executable.wasmHash().toString('base64')
+        case 'error':
+            return value.toXDR('base64')
+        case 'contractId':
+            return xdrParseContractAddress(value._value)
+        default:
+            if (value.switch().name === 'scvVoid') //scVoid
+                return undefined
+            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value.toXDR ? value.toXDR() : value.toString())
+    }
+}
+
+module.exports = {
+    xdrParseAsset,
+    xdrParseAccountAddress,
+    xdrParseContractAddress,
+    xdrParseClaimant,
+    xdrParseClaimedOffer,
+    xdrParseTradeAtom,
+    xdrParseSignerKey,
+    xdrParsePrice,
+    xdrParseScVal
+}