@stellar-expert/ui-framework 1.16.8 → 1.19.0

package/tx/op-icon.js

@@ -1,99 +1,99 @@
-import React from 'react'
-import cn from 'classnames'
-
-const opIconMapping = {
-    feeCharge: 'send-circle',
-    createAccount: 'hexagon-add',
-    payment: 'send-circle',
-    paymentReceive: 'receive-circle',
-    pathPaymentStrictReceive: 'swap',
-    manageSellOffer: 'dex-offer',
-    createPassiveSellOffer: 'dex-offer',
-    setOptions: 'hexagon-set-options',
-    changeTrust: 'trustlines',
-    changeTrustAdd: 'create-trustline',
-    changeTrustRemove: 'remove-trustline',
-    changeTrustUpdate: 'trustline-flags',
-    allowTrust: 'trustline-flags',
-    accountMerge: 'hexagon-remove',
-    accountMergeReceive: 'receive-circle',
-    inflation: 'hexagon-inflation',
-    manageData: 'grid',
-    manageDataAdd: 'grid-add',
-    manageDataRemove: 'grid-remove',
-    bumpSequence: 'upload',
-    manageBuyOffer: 'dex-offer',
-    pathPaymentStrictSend: 'swap',
-    createClaimableBalance: 'shutdown-circle',
-    claimClaimableBalance: 'icon-ok',
-    claimClaimableBalanceReceive: 'receive-circle',
-    beginSponsoringFutureReserves: 'sponsor',
-    endSponsoringFutureReserves: 'sponsor',
-    revoke: 'revoke',
-    revokeAccountSponsorship: 'revoke',
-    revokeTrustlineSponsorship: 'revoke',
-    revokeOfferSponsorship: 'revoke',
-    revokeDataSponsorship: 'revoke',
-    revokeClaimableBalanceSponsorship: 'revoke',
-    revokeLiquidityPoolSponsorship: 'revoke',
-    revokeSignerSponsorship: 'revoke',
-    clawback: 'clawback',
-    clawbackReceive: 'send-circle',
-    clawbackClaimableBalance: 'icon-ok',
-    setTrustLineFlags: 'trustline-flags',
-    liquidityPoolDeposit: 'droplet',
-    liquidityPoolWithdraw: 'droplet-half',
-    invokeHostFunction: 'flash',
-    extendFootprintTtl: 'upload',
-    restoreFootprint: 'upload'
-}
-
-/**
- * Transaction operation icon
- * @param {OperationDescriptor|'feeCharge'} op - Operation descriptor
- * @param {Boolean} failed - Whether the transaction failed during execution
- * @constructor
- */
-export const OpIcon = React.memo(function OpIcon({op, failed = false}) {
-    let type
-    let title
-    if (op === 'feeCharge') {
-        type = 'feeCharge'
-        title = 'Transaction fees charge'
-    } else {
-        const {operation} = op
-        title = type = operation.type
-        title = title[0].toUpperCase() + title.substring(1) + ' operation'
-        switch (type) {
-            case 'payment':
-            case 'accountMerge':
-            case 'claimClaimableBalance':
-            case 'clawback':
-                if (!op.context?.account?.includes(operation.source)) {
-                    type += 'Receive'
-                }
-                break
-            case 'manageData':
-                if (operation.effects.some(e => e.type === 'dataEntryCreated')) {
-                    type += 'Add'
-                } else if (operation.effects.some(e => e.type === 'dataEntryRemoved')) {
-                    type += 'Remove'
-                }
-                break
-            case 'changeTrust':
-                if (operation.limit > 0) {
-                    type += 'Add'
-                } else {
-                    type += 'Remove'
-                }
-                break
-        }
-    }
-    if (failed) {
-        title += ' - Transaction failed'
-    }
-    const icon = opIconMapping[type]
-    return <div className={cn('op-icon', {failed})} title={title}>
-        <i className={`icon-${icon}`}/>
-    </div>
+import React from 'react'
+import cn from 'classnames'
+
+const opIconMapping = {
+    feeCharge: 'send-circle',
+    createAccount: 'hexagon-add',
+    payment: 'send-circle',
+    paymentReceive: 'receive-circle',
+    pathPaymentStrictReceive: 'swap',
+    manageSellOffer: 'dex-offer',
+    createPassiveSellOffer: 'dex-offer',
+    setOptions: 'hexagon-set-options',
+    changeTrust: 'trustlines',
+    changeTrustAdd: 'create-trustline',
+    changeTrustRemove: 'remove-trustline',
+    changeTrustUpdate: 'trustline-flags',
+    allowTrust: 'trustline-flags',
+    accountMerge: 'hexagon-remove',
+    accountMergeReceive: 'receive-circle',
+    inflation: 'hexagon-inflation',
+    manageData: 'grid',
+    manageDataAdd: 'grid-add',
+    manageDataRemove: 'grid-remove',
+    bumpSequence: 'upload',
+    manageBuyOffer: 'dex-offer',
+    pathPaymentStrictSend: 'swap',
+    createClaimableBalance: 'shutdown-circle',
+    claimClaimableBalance: 'icon-ok',
+    claimClaimableBalanceReceive: 'receive-circle',
+    beginSponsoringFutureReserves: 'sponsor',
+    endSponsoringFutureReserves: 'sponsor',
+    revoke: 'revoke',
+    revokeAccountSponsorship: 'revoke',
+    revokeTrustlineSponsorship: 'revoke',
+    revokeOfferSponsorship: 'revoke',
+    revokeDataSponsorship: 'revoke',
+    revokeClaimableBalanceSponsorship: 'revoke',
+    revokeLiquidityPoolSponsorship: 'revoke',
+    revokeSignerSponsorship: 'revoke',
+    clawback: 'clawback',
+    clawbackReceive: 'send-circle',
+    clawbackClaimableBalance: 'icon-ok',
+    setTrustLineFlags: 'trustline-flags',
+    liquidityPoolDeposit: 'droplet',
+    liquidityPoolWithdraw: 'droplet-half',
+    invokeHostFunction: 'flash',
+    extendFootprintTtl: 'upload',
+    restoreFootprint: 'upload'
+}
+
+/**
+ * Transaction operation icon
+ * @param {OperationDescriptor|'feeCharge'} op - Operation descriptor
+ * @param {boolean} failed - Whether the transaction failed during execution
+ * @constructor
+ */
+export const OpIcon = React.memo(function OpIcon({op, failed = false}) {
+    let type
+    let title
+    if (op === 'feeCharge') {
+        type = 'feeCharge'
+        title = 'Transaction fees charge'
+    } else {
+        const {operation} = op
+        title = type = operation.type
+        title = title[0].toUpperCase() + title.substring(1) + ' operation'
+        switch (type) {
+            case 'payment':
+            case 'accountMerge':
+            case 'claimClaimableBalance':
+            case 'clawback':
+                if (!op.context?.account?.includes(operation.source)) {
+                    type += 'Receive'
+                }
+                break
+            case 'manageData':
+                if (operation.effects.some(e => e.type === 'dataEntryCreated')) {
+                    type += 'Add'
+                } else if (operation.effects.some(e => e.type === 'dataEntryRemoved')) {
+                    type += 'Remove'
+                }
+                break
+            case 'changeTrust':
+                if (operation.limit > 0) {
+                    type += 'Add'
+                } else {
+                    type += 'Remove'
+                }
+                break
+        }
+    }
+    if (failed) {
+        title += ' - Transaction failed'
+    }
+    const icon = opIconMapping[type]
+    return <div className={cn('op-icon', {failed})} title={title}>
+        <i className={`icon-${icon}`}/>
+    </div>
 })

package/tx/parser/op-balance-changes.js

@@ -1,66 +1,66 @@
-const manageOfferOpTypes = ['manageSellOffer', 'manageBuyOffer', 'createPassiveSellOffer']
-
-/**
- * Calculate operation resulting balance changes
- * @param {{}} op - Operation descriptor
- * @return {{amount: String, source: String, type: String, asset: String}[]}
- */
-export function retrieveOpBalanceChanges(op) {
-    const account = op.tx?.context?.account
-    if (typeof account !== 'string')
-        return []
-    const {effects} = op.operation
-    const changes = effects.filter(e => e.source === account && (e.type === 'accountDebited' || e.type === 'accountCredited'))
-    if (changes.length) {
-        changes.sort((a, b) => a.type - b.type)
-        return changes
-    }
-
-    /*if (manageOfferOpTypes.includes(op.operation.type)) {
-        const debitedAmounts = []
-        const creditedAmounts = []
-        let sourceAsset
-        let destAsset
-
-        for (let e of effects) {
-            if (![e.seller, e.source].includes(op.context) || e.type !== 'trade')
-                continue
-            let {amount} = e
-            sourceAsset = e.asset[1]
-            destAsset = e.asset[0]
-            if (e.seller === op.context) {
-                amount = amount.slice().reverse()
-                sourceAsset = e.asset[1]
-                destAsset = e.asset[0]
-            }
-            debitedAmounts.push(amount[1])
-            creditedAmounts.push(amount[0])
-        }
-        const res = []
-        if (debitedAmounts.length) {
-            res.push({
-                type: 'accountDebited',
-                source: op.context,
-                asset: sourceAsset,
-                amount: sumAmounts(debitedAmounts)
-            })
-        }
-
-        if (creditedAmounts.length) {
-            res.push({
-                type: 'accountCredited',
-                source: op.context,
-                asset: destAsset,
-                amount: sumAmounts(creditedAmounts)
-            })
-        }
-        return res
-    }*/
-    return []
-}
-
-/*
-
-function sumAmounts(amounts) {
-    return amounts.reduce((prev, v) => prev.add(v), new Bignumber(0))
-}*/
+const manageOfferOpTypes = ['manageSellOffer', 'manageBuyOffer', 'createPassiveSellOffer']
+
+/**
+ * Calculate operation resulting balance changes
+ * @param {{}} op - Operation descriptor
+ * @return {{amount: string, source: string, type: string, asset: string}[]}
+ */
+export function retrieveOpBalanceChanges(op) {
+    const account = op.tx?.context?.account
+    if (typeof account !== 'string')
+        return []
+    const {effects} = op.operation
+    const changes = effects.filter(e => e.source === account && (e.type === 'accountDebited' || e.type === 'accountCredited'))
+    if (changes.length) {
+        changes.sort((a, b) => a.type - b.type)
+        return changes
+    }
+
+    /*if (manageOfferOpTypes.includes(op.operation.type)) {
+        const debitedAmounts = []
+        const creditedAmounts = []
+        let sourceAsset
+        let destAsset
+
+        for (let e of effects) {
+            if (![e.seller, e.source].includes(op.context) || e.type !== 'trade')
+                continue
+            let {amount} = e
+            sourceAsset = e.asset[1]
+            destAsset = e.asset[0]
+            if (e.seller === op.context) {
+                amount = amount.slice().reverse()
+                sourceAsset = e.asset[1]
+                destAsset = e.asset[0]
+            }
+            debitedAmounts.push(amount[1])
+            creditedAmounts.push(amount[0])
+        }
+        const res = []
+        if (debitedAmounts.length) {
+            res.push({
+                type: 'accountDebited',
+                source: op.context,
+                asset: sourceAsset,
+                amount: sumAmounts(debitedAmounts)
+            })
+        }
+
+        if (creditedAmounts.length) {
+            res.push({
+                type: 'accountCredited',
+                source: op.context,
+                asset: destAsset,
+                amount: sumAmounts(creditedAmounts)
+            })
+        }
+        return res
+    }*/
+    return []
+}
+
+/*
+
+function sumAmounts(amounts) {
+    return amounts.reduce((prev, v) => prev.add(v), new Bignumber(0))
+}*/

package/tx/parser/op-descriptor.js

@@ -1,49 +1,52 @@
-export default class OperationDescriptor {
-    /**
-     * @type {BaseOperation} - Operation properties
-     * @readonly
-     */
-    operation
-    /**
-     * @type {String} - Parent transaction hash
-     * @readonly
-     */
-    txHash
-    /**
-     * @type {Number} - Application order
-     * @readonly
-     */
-    order
-    /**
-     * @type {Boolean} - True for unsubmitted|unsuccessful transactions
-     * @readonly
-     */
-    isEphemeral
-    /**
-     * @type {Boolean} - Whether the enclosing transaction has been successfully executed
-     * @readonly
-     */
-    successful
-
-    /**
-     * Prepare descriptors for transaction operations
-     * @param {BaseOperation[]} operations
-     * @param {String} txHash
-     * @param {Boolean} isEphemeral
-     * @param {Boolean} successful
-     * @return {OperationDescriptor[]}
-     */
-    static parseOperations(operations, txHash, isEphemeral, successful) {
-        return operations.map((operation, i) => {
-            const op = new OperationDescriptor()
-            Object.assign(op, {
-                txHash,
-                order: i,
-                operation,
-                isEphemeral,
-                successful
-            })
-            return op
-        })
-    }
+/**
+ * Operation rendering context
+ */
+export default class OperationDescriptor {
+    /**
+     * @type {BaseOperation} - Operation properties
+     * @readonly
+     */
+    operation
+    /**
+     * @type {string} - Parent transaction hash
+     * @readonly
+     */
+    txHash
+    /**
+     * @type {number} - Application order
+     * @readonly
+     */
+    order
+    /**
+     * @type {boolean} - True for unsubmitted|unsuccessful transactions
+     * @readonly
+     */
+    isEphemeral
+    /**
+     * @type {boolean} - Whether the enclosing transaction has been successfully executed
+     * @readonly
+     */
+    successful
+
+    /**
+     * Prepare descriptors for transaction operations
+     * @param {BaseOperation[]} operations
+     * @param {string} txHash
+     * @param {boolean} isEphemeral
+     * @param {boolean} successful
+     * @return {OperationDescriptor[]}
+     */
+    static parseOperations(operations, txHash, isEphemeral, successful) {
+        return operations.map((operation, i) => {
+            const op = new OperationDescriptor()
+            Object.assign(op, {
+                txHash,
+                order: i,
+                operation,
+                isEphemeral,
+                successful
+            })
+            return op
+        })
+    }
 }

package/tx/parser/tx-details-parser.js

@@ -1,81 +1,81 @@
-import {parseTxOperationsMeta} from '@stellar-expert/tx-meta-effects-parser'
-import OperationDescriptor from './op-descriptor'
-import TxMatcher from './tx-matcher'
-
-/**
- * @typedef {Object} ParsedTxDetails - Parsed transaction
- * @property {OperationDescriptor[]} operations - Parsed operation descriptors
- * @property {Transaction|FeeBumpTransaction} tx - Parsed transaction
- * @property {String} txHash - Transaction hash
- * @property {String} context - Account address, asset name, offer id
- * @property {String} contextType - Resolved context type
- * @property {Boolean} isEphemeral - True if transaction has not been submitted or rejected
- * @property {Boolean} unmatched - Whether transaction matches context and filter
- * @property {Boolean} [successful] - Whether the transaction has been executed successfully or failed during execution
- * @property {{}[]} [effects] - Transaction-level effects (including fee charges)
- * @property {String} [createdAt] - Ledger application timestamp
- */
-
-/**
- * @typedef {Object} TxFiltersContext
- * @property {String[]} [type]
- * @property {String[]} [account]
- * @property {String[]} [source]
- * @property {String[]} [destination]
- * @property {String[]} [asset]
- * @property {String[]} [src_asset]
- * @property {String[]} [dest_asset]
- * @property {String[]} [offer]
- * @property {String[]} [pool]
- */
-
-/**
- * Parse tx details from raw envelope, result, and meta
- * @param {String} network - Network passphrase or identifier
- * @param {String} tx - Base64-encoded tx envelope xdr
- * @param {String} [result] - Base64-encoded tx envelope result
- * @param {String} [meta] - Base64-encoded tx envelope meta
- * @param {String} [id] - Unique transaction id
- * @param {TxFiltersContext} [context] - Filters applied to transactions search
- * @param {String} [createdAt] - Ledger execution timestamp
- * @param {Boolean} [skipUnrelated] - Ledger execution timestamp
- * @param {Number} [protocol] – Specific Stellar protocol version for the executed transaction
- * @return {ParsedTxDetails}
- */
-export function parseTxDetails({network, txEnvelope, result, meta, id, context, createdAt, skipUnrelated, protocol}) {
-    const parsedTx = parseTxOperationsMeta({network, tx: txEnvelope, meta, result, protocol, processSystemEvents: true, processFailedOpEffects: true, mapSac: true})
-    const {tx, effects, operations, isEphemeral, failed} = parsedTx
-    const txHash = tx.hash().toString('hex')
-    const txMatcher = new TxMatcher(context, skipUnrelated)
-    let parsedOps = OperationDescriptor.parseOperations(operations, txHash, isEphemeral, !isEphemeral && !failed)
-    //filter out irrelevant operations
-    const matchedOps = parsedOps.filter(od => txMatcher.matchOperation(od))
-    //display only relevant operations or all of them if no relevant operations found
-    if (matchedOps.length) {
-        parsedOps = matchedOps
-    }
-    const res = {
-        operations: parsedOps,
-        tx,
-        txHash,
-        context,
-        isEphemeral,
-        unmatched: !parsedOps.length
-    }
-    if (!isEphemeral) {
-        res.effects = effects
-    }
-    if (createdAt) {
-        res.createdAt = createdAt
-    }
-    if (!isEphemeral) {
-        res.successful = !failed
-    }
-    if (id !== undefined) {
-        res.id = id
-    }
-    for (let op of parsedOps) {
-        op.tx = res
-    }
-    return res
-}
+import {parseTxOperationsMeta} from '@stellar-expert/tx-meta-effects-parser'
+import OperationDescriptor from './op-descriptor'
+import TxMatcher from './tx-matcher'
+
+/**
+ * @typedef {Object} ParsedTxDetails - Parsed transaction
+ * @property {OperationDescriptor[]} operations - Parsed operation descriptors
+ * @property {Transaction|FeeBumpTransaction} tx - Parsed transaction
+ * @property {string} txHash - Transaction hash
+ * @property {string} context - Account address, asset name, offer id
+ * @property {string} contextType - Resolved context type
+ * @property {boolean} isEphemeral - True if transaction has not been submitted or rejected
+ * @property {boolean} unmatched - Whether transaction matches context and filter
+ * @property {boolean} [successful] - Whether the transaction has been executed successfully or failed during execution
+ * @property {{}[]} [effects] - Transaction-level effects (including fee charges)
+ * @property {string} [createdAt] - Ledger application timestamp
+ */
+
+/**
+ * @typedef {Object} TxFiltersContext
+ * @property {string[]} [type]
+ * @property {string[]} [account]
+ * @property {string[]} [source]
+ * @property {string[]} [destination]
+ * @property {String[]} [asset]
+ * @property {String[]} [src_asset]
+ * @property {String[]} [dest_asset]
+ * @property {String[]} [offer]
+ * @property {String[]} [pool]
+ */
+
+/**
+ * Parse tx details from raw envelope, result, and meta
+ * @param {String} network - Network passphrase or identifier
+ * @param {String} tx - Base64-encoded tx envelope xdr
+ * @param {String} [result] - Base64-encoded tx envelope result
+ * @param {String} [meta] - Base64-encoded tx envelope meta
+ * @param {String} [id] - Unique transaction id
+ * @param {TxFiltersContext} [context] - Filters applied to transactions search
+ * @param {String} [createdAt] - Ledger execution timestamp
+ * @param {boolean} [skipUnrelated] - Ledger execution timestamp
+ * @param {number} [protocol] – Specific Stellar protocol version for the executed transaction
+ * @return {ParsedTxDetails}
+ */
+export function parseTxDetails({network, txEnvelope, result, meta, id, context, createdAt, skipUnrelated, protocol}) {
+    const parsedTx = parseTxOperationsMeta({network, tx: txEnvelope, meta, result, protocol, processSystemEvents: true, processFailedOpEffects: true, mapSac: true})
+    const {tx, effects, operations, isEphemeral, failed} = parsedTx
+    const txHash = tx.hash().toString('hex')
+    const txMatcher = new TxMatcher(context, skipUnrelated)
+    let parsedOps = OperationDescriptor.parseOperations(operations, txHash, isEphemeral, !isEphemeral && !failed)
+    //filter out irrelevant operations
+    const matchedOps = parsedOps.filter(od => txMatcher.matchOperation(od))
+    //display only relevant operations or all of them if no relevant operations found
+    if (matchedOps.length) {
+        parsedOps = matchedOps
+    }
+    const res = {
+        operations: parsedOps,
+        tx,
+        txHash,
+        context,
+        isEphemeral,
+        unmatched: !parsedOps.length
+    }
+    if (!isEphemeral) {
+        res.effects = effects
+    }
+    if (createdAt) {
+        res.createdAt = createdAt
+    }
+    if (!isEphemeral) {
+        res.successful = !failed
+    }
+    if (id !== undefined) {
+        res.id = id
+    }
+    for (let op of parsedOps) {
+        op.tx = res
+    }
+    return res
+}