@stellar-expert/tx-meta-effects-parser 8.3.3 → 8.4.0

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

@@ -1,352 +1,352 @@
-const {
-    xdr,
-    StrKey,
-    LiquidityPoolId,
-    scValToBigInt,
-    encodeMuxedAccount,
-    encodeMuxedAccountToAddress
-} = require('@stellar/stellar-base')
-const {TxMetaEffectParserError} = require('../errors')
-const effectTypes = require('../effect-types')
-
-/**
- * Parse account address from XDR representation
- * @param accountId
- * @return {String}
- */
-function xdrParseAccountAddress(accountId) {
-    if (!accountId)
-        return undefined
-    if (accountId.arm) {
-        switch (accountId.arm()) {
-            case 'ed25519':
-                return StrKey.encodeEd25519PublicKey(accountId.ed25519())
-            case 'med25519':
-                return {
-                    primary: StrKey.encodeEd25519PublicKey(accountId.value().ed25519()),
-                    muxedId: accountId.value().id().toString()
-                }
-            default:
-                throw new TxMetaEffectParserError(`Unsupported account type: ${accountId.arm()}`)
-        }
-    }
-    if (accountId instanceof Uint8Array) {
-        return StrKey.encodeEd25519PublicKey(accountId)
-    }
-    throw new TypeError(`Failed to identify and parse account address: ${accountId}`)
-}
-
-/**
- * Parse muxed account address from ScAddress XDR representation
- * @param {{}} value
- * @return {string}
- */
-function xdrParseMuxedScAddress(value) {
-    const {ed25519, id} = value._attributes
-    const muxed = encodeMuxedAccount(StrKey.encodeEd25519PublicKey(ed25519), id._value.toString())
-    return encodeMuxedAccountToAddress(muxed)
-}
-
-/**
- * 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()
-}
-
-/**
- * @param {string} address
- * @return {string}
- */
-function retrieveBaseMuxedAddress(address) {
-    const rawBytes = StrKey.decodeMed25519PublicKey(address)
-    return StrKey.encodeEd25519PublicKey(rawBytes.subarray(0, 32))
-}
-
-/**
- * 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':
-            let key = signer.ed25519SignedPayload()
-            if (key._attributes){
-                key = key._attributes.ed25519
-            }
-            return StrKey.encodeSignedPayload(key) //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')
-            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.includes('-'))
-            return src //already parsed
-        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':
-            return scValToBigInt(value).toString()
-        case 'timepoint':
-        case 'duration':
-            return value._value._value.toString()
-        case 'address':
-            switch (value._value._arm) {
-                case 'accountId':
-                    return xdrParseAccountAddress(value._value.value())
-                case 'contractId':
-                    return xdrParseContractAddress(value._value.value())
-                case 'muxedAccount':
-                    return xdrParseMuxedScAddress(value._value.value())
-            }
-            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value._value._arm.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:
-            switch (value._switch.name) {
-                case 'scvVoid':
-                    return undefined
-                case 'scvContractInstance':
-                    return '<ContractInstance>'
-                case 'scvLedgerKeyContractInstance':
-                    return '<LedgerKeyContractInstance>'
-                case 'scvLedgerKeyNonce':
-                    return '<LedgerKeyNonce>'
-            }
-            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value.toXDR ? value.toXDR() : value.toString())
-    }
-}
-
-function xdrParseSacBalanceChange(changeEventType, key, value) {
-    const parsedKey = xdr.ScVal.fromXDR(key, 'base64')
-    if (parsedKey._arm !== 'vec')
-        return null
-    const keyParts = parsedKey._value
-    if (!(keyParts instanceof Array) || keyParts.length !== 2)
-        return null
-    if (keyParts[0]._arm !== 'sym' || keyParts[1]._arm !== 'address' || keyParts[0]._value.toString() !== 'Balance')
-        return null
-    const res = {
-        address: xdrParseScVal(keyParts[1]),
-        balance: changeEventType===effectTypes.contractDataRemoved?
-            '0':
-            retrieveBalanceFromStateData(value)
-    }
-    if (res.balance === undefined)
-        return null
-    return res
-}
-
-function retrieveBalanceFromStateData(value) {
-    const xdrVal = xdr.ScVal.fromXDR(value, 'base64')
-    if (xdrVal._arm !== 'map')
-        return undefined
-    const parsedValue = xdrParseScVal(xdrVal)
-    if (typeof parsedValue.amount !== 'string')
-        return undefined
-    return parsedValue.amount
-}
-
-module.exports = {
-    xdrParseAsset,
-    xdrParseAccountAddress,
-    xdrParseContractAddress,
-    xdrParseMuxedScAddress,
-    xdrParseClaimant,
-    xdrParseClaimedOffer,
-    xdrParseTradeAtom,
-    xdrParseSignerKey,
-    xdrParsePrice,
-    xdrParseScVal,
-    xdrParseSacBalanceChange,
-    retrieveBaseMuxedAddress
-}
+const {
+    xdr,
+    StrKey,
+    LiquidityPoolId,
+    scValToBigInt,
+    encodeMuxedAccount,
+    encodeMuxedAccountToAddress
+} = require('@stellar/stellar-base')
+const {TxMetaEffectParserError} = require('../errors')
+const effectTypes = require('../effect-types')
+
+/**
+ * Parse account address from XDR representation
+ * @param accountId
+ * @return {String}
+ */
+function xdrParseAccountAddress(accountId) {
+    if (!accountId)
+        return undefined
+    if (accountId.arm) {
+        switch (accountId.arm()) {
+            case 'ed25519':
+                return StrKey.encodeEd25519PublicKey(accountId.ed25519())
+            case 'med25519':
+                return {
+                    primary: StrKey.encodeEd25519PublicKey(accountId.value().ed25519()),
+                    muxedId: accountId.value().id().toString()
+                }
+            default:
+                throw new TxMetaEffectParserError(`Unsupported account type: ${accountId.arm()}`)
+        }
+    }
+    if (accountId instanceof Uint8Array) {
+        return StrKey.encodeEd25519PublicKey(accountId)
+    }
+    throw new TypeError(`Failed to identify and parse account address: ${accountId}`)
+}
+
+/**
+ * Parse muxed account address from ScAddress XDR representation
+ * @param {{}} value
+ * @return {string}
+ */
+function xdrParseMuxedScAddress(value) {
+    const {ed25519, id} = value._attributes
+    const muxed = encodeMuxedAccount(StrKey.encodeEd25519PublicKey(ed25519), id._value.toString())
+    return encodeMuxedAccountToAddress(muxed)
+}
+
+/**
+ * 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()
+}
+
+/**
+ * @param {string} address
+ * @return {string}
+ */
+function retrieveBaseMuxedAddress(address) {
+    const rawBytes = StrKey.decodeMed25519PublicKey(address)
+    return StrKey.encodeEd25519PublicKey(rawBytes.subarray(0, 32))
+}
+
+/**
+ * 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':
+            let key = signer.ed25519SignedPayload()
+            if (key._attributes){
+                key = key._attributes.ed25519
+            }
+            return StrKey.encodeSignedPayload(key) //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')
+            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.includes('-'))
+            return src //already parsed
+        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':
+            return scValToBigInt(value).toString()
+        case 'timepoint':
+        case 'duration':
+            return value._value._value.toString()
+        case 'address':
+            switch (value._value._arm) {
+                case 'accountId':
+                    return xdrParseAccountAddress(value._value.value())
+                case 'contractId':
+                    return xdrParseContractAddress(value._value.value())
+                case 'muxedAccount':
+                    return xdrParseMuxedScAddress(value._value.value())
+            }
+            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value._value._arm.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:
+            switch (value._switch.name) {
+                case 'scvVoid':
+                    return undefined
+                case 'scvContractInstance':
+                    return '<ContractInstance>'
+                case 'scvLedgerKeyContractInstance':
+                    return '<LedgerKeyContractInstance>'
+                case 'scvLedgerKeyNonce':
+                    return '<LedgerKeyNonce>'
+            }
+            throw new TxMetaEffectParserError('Not supported XDR primitive type: ' + value.toXDR ? value.toXDR() : value.toString())
+    }
+}
+
+function xdrParseSacBalanceChange(changeEventType, key, value) {
+    const parsedKey = xdr.ScVal.fromXDR(key, 'base64')
+    if (parsedKey._arm !== 'vec')
+        return null
+    const keyParts = parsedKey._value
+    if (!(keyParts instanceof Array) || keyParts.length !== 2)
+        return null
+    if (keyParts[0]._arm !== 'sym' || keyParts[1]._arm !== 'address' || keyParts[0]._value.toString() !== 'Balance')
+        return null
+    const res = {
+        address: xdrParseScVal(keyParts[1]),
+        balance: changeEventType===effectTypes.contractDataRemoved?
+            '0':
+            retrieveBalanceFromStateData(value)
+    }
+    if (res.balance === undefined)
+        return null
+    return res
+}
+
+function retrieveBalanceFromStateData(value) {
+    const xdrVal = xdr.ScVal.fromXDR(value, 'base64')
+    if (xdrVal._arm !== 'map')
+        return undefined
+    const parsedValue = xdrParseScVal(xdrVal)
+    if (typeof parsedValue.amount !== 'string')
+        return undefined
+    return parsedValue.amount
+}
+
+module.exports = {
+    xdrParseAsset,
+    xdrParseAccountAddress,
+    xdrParseContractAddress,
+    xdrParseMuxedScAddress,
+    xdrParseClaimant,
+    xdrParseClaimedOffer,
+    xdrParseTradeAtom,
+    xdrParseSignerKey,
+    xdrParsePrice,
+    xdrParseScVal,
+    xdrParseSacBalanceChange,
+    retrieveBaseMuxedAddress
+}