loading
diff --git a/client/src/controllers/TxController.js b/client/src/controllers/TxController.js
index 6b00ece..81962dd 100644
--- a/client/src/controllers/TxController.js
+++ b/client/src/controllers/TxController.js
@@ -6,17 +6,21 @@ import BitcoinBlock from '../models/BitcoinBlock.js'
import TxSprite from '../models/TxSprite.js'
import { FastVertexArray } from '../utils/memory.js'
import { searchTx, fetchSpends, addSpends } from '../utils/search.js'
-import { overlay, txCount, mempoolCount, mempoolScreenHeight, blockVisible, currentBlock, selectedTx, detailTx, blockAreaSize, highlight, colorMode, blocksEnabled, latestBlockHeight, explorerBlock, blockTransitionDirection, loading, urlPath } from '../stores.js'
+import { highlightE } from '../utils/color.js'
+import { overlay, txCount, mempoolCount, mempoolScreenHeight, mempoolScreenLeft, blockVisible, currentBlock, selectedTx, detailTx, blockAreaSize, highlight, focusTx, colorMode, settings, blocksEnabled, latestBlockHeight, explorerBlock, blockTransitionDirection, loading, urlPath } from '../stores.js'
import config from "../config.js"
import { tick } from 'svelte';
+const nextFrame = () => new Promise(resolve => requestAnimationFrame(resolve))
+
export default class TxController {
constructor ({ width, height }) {
this.vertexArray = new FastVertexArray(2048, TxSprite.dataSize, txCount)
+ this.trailVertexArray = new FastVertexArray(512, TxSprite.dataSize)
this.debugVertexArray = new FastVertexArray(1024, TxSprite.dataSize)
this.txs = {}
this.expiredTxs = {}
- this.poolScene = new TxMondrianPoolScene({ width, height, controller: this, heightStore: mempoolScreenHeight })
+ this.poolScene = new TxMondrianPoolScene({ width, height, controller: this, heightStore: mempoolScreenHeight, leftStore: mempoolScreenLeft })
this.blockAreaSize = (width <= 620) ? Math.min(window.innerWidth * 0.7, window.innerHeight / 2.75) : Math.min(window.innerWidth * 0.75, window.innerHeight / 2.5)
blockAreaSize.set(this.blockAreaSize)
this.blockScene = null
@@ -33,8 +37,13 @@ export default class TxController {
this.lastTxTime = 0
this.txDelay = 0
+ this.showGhostTrails = true
this.blocksEnabled = true
+ settings.subscribe(value => {
+ this.showGhostTrails = value.showGhostTrails !== false
+ if (!this.showGhostTrails) this.poolScene.clearEntryTrails()
+ })
blocksEnabled.subscribe(enabled => {
this.blocksEnabled = enabled
})
@@ -45,6 +54,12 @@ export default class TxController {
this.highlightCriteria = criteria
this.applyHighlighting()
})
+ focusTx.subscribe(txid => {
+ if (txid) {
+ this.focusTx(txid)
+ focusTx.set(null)
+ }
+ })
colorMode.subscribe(mode => {
this.setColorMode(mode)
})
@@ -58,7 +73,14 @@ export default class TxController {
}
getVertexData () {
- return this.vertexArray.getVertexData()
+ const vertexData = this.vertexArray.getVertexData()
+ if (!this.trailVertexArray.count) return vertexData
+
+ const trailData = this.trailVertexArray.getVertexData()
+ const combined = new Float32Array(vertexData.length + trailData.length)
+ combined.set(vertexData)
+ combined.set(trailData, vertexData.length)
+ return combined
}
getDebugVertexData () {
@@ -108,6 +130,10 @@ export default class TxController {
}
}
+ focusTx (txid) {
+ if (this.txs[txid]) this.txs[txid].focusPulse()
+ }
+
addTx (txData) {
const tx = new BitcoinTx(txData, this.vertexArray)
tx.applyHighlighting(this.highlightCriteria)
@@ -127,23 +153,44 @@ export default class TxController {
}
dropTx (txid) {
- if (this.txs[txid] && this.poolScene.drop(txid)) {
- this.txs[txid].view.update({
+ const tx = this.txs[txid]
+ if (tx && this.poolScene.drop(txid)) {
+ const radius = tx.screenPosition.r
+ const warningColor = {
+ h: highlightE.h + ((Math.random() - 0.5) * 0.04),
+ l: highlightE.l + ((Math.random() - 0.5) * 0.08)
+ }
+ tx.hoverOff()
+ tx.highlightOff()
+ tx.view.destroyLens()
+ if (this.selectedTx === tx) {
+ this.selectedTx = null
+ selectedTx.set(null)
+ }
+ tx.view.update({
+ display: {
+ color: warningColor
+ },
+ delay: 0,
+ duration: 1500,
+ smooth: 'in'
+ })
+ tx.view.update({
display: {
position: {
- y: -100, //this.txs[txid].screenPosition.y - 100
+ r: Math.min(Math.max(radius * 3, radius + 12), radius + 48)
},
- // color: {
- // alpha: 0
- // }
+ color: {
+ alpha: 0
+ }
},
- delay: 0,
- duration: 2000
+ delay: 1200,
+ duration: 900,
+ smooth: true
})
setTimeout(() => {
this.destroyTx(txid)
- }, 2000)
- // this.poolScene.layoutAll()
+ }, 2100)
}
}
@@ -284,7 +331,7 @@ export default class TxController {
async exploreBlock (block) {
if (this.block && this.block.id === block.id) {
- this.showBlock()
+ await this.resumeLatest({ updateUrl: false })
return
}
@@ -295,19 +342,20 @@ export default class TxController {
const prevBlock = this.explorerBlock
const prevBlockScene = this.explorerBlockScene
if (prevBlock.height < block.height) {
- prevBlockScene.exitLeft()
+ await prevBlockScene.exitAsync(false)
enterFromRight = true
}
- else prevBlockScene.exitRight()
+ else await prevBlockScene.exitAsync(true)
prevBlockScene.expire(3000)
} else if (this.blockScene) {
- this.blockScene.exitRight()
+ await this.blockScene.exitAsync(true)
}
this.explorerBlock = block
if (this.blocksEnabled) {
- this.explorerBlockScene = new TxBlockScene({ width: this.blockAreaSize, height: this.blockAreaSize, blockId: block.id, controller: this, colorMode: this.colorMode })
+ const explorerBlockScene = new TxBlockScene({ width: this.blockAreaSize, height: this.blockAreaSize, blockId: block.id, controller: this, colorMode: this.colorMode })
+ this.explorerBlockScene = explorerBlockScene
for (let i = 0; i < block.txns.length; i++) {
const tx = new BitcoinTx({
...block.txns[i],
@@ -315,17 +363,17 @@ export default class TxController {
}, this.vertexArray)
this.txs[tx.id] = tx
this.txs[tx.id].applyHighlighting(this.highlightCriteria)
- this.explorerBlockScene.insert(tx, 0, false)
- }
- this.explorerBlockScene.prepareAll()
- this.explorerBlockScene.layoutAll()
- if (enterFromRight) {
- blockTransitionDirection.set('right')
- this.explorerBlockScene.enterRight()
- } else {
- blockTransitionDirection.set('left')
- this.explorerBlockScene.enterLeft()
+ explorerBlockScene.insert(tx, 0, false)
}
+
+ await nextFrame()
+ explorerBlockScene.prepareAll()
+ await nextFrame()
+ explorerBlockScene.layoutAll()
+ await nextFrame()
+
+ blockTransitionDirection.set(enterFromRight ? 'right' : 'left')
+ await explorerBlockScene.enterAsync(enterFromRight)
}
blockVisible.set(true)
@@ -333,7 +381,7 @@ export default class TxController {
currentBlock.set(block)
}
- async resumeLatest () {
+ async resumeLatest ({ updateUrl = true } = {}) {
if (this.explorerBlock && this.explorerBlockScene) {
const prevBlock = this.explorerBlock
const prevBlockScene = this.explorerBlockScene
@@ -341,7 +389,7 @@ export default class TxController {
prevBlockScene.expire(3000)
this.explorerBlockScene = null
this.explorerBlock = null
- urlPath.set("/")
+ if (updateUrl) urlPath.set("/")
}
if (this.blockScene && this.block) {
blockTransitionDirection.set('right')
@@ -365,6 +413,19 @@ export default class TxController {
}
}
+ replayLatestBlock () {
+ if (this.blockScene && !this.explorerBlockScene) {
+ blockTransitionDirection.set(null)
+ blockVisible.set(true)
+ this.blockScene.replayBuild()
+ }
+ }
+
+ setBlockOpacity (opacity, duration) {
+ if (this.blockScene) this.blockScene.setOpacity(opacity, duration)
+ if (this.explorerBlockScene) this.explorerBlockScene.setOpacity(opacity, duration)
+ }
+
clearBlock () {
if (this.blockScene) {
this.blockScene.exitLeft()
@@ -395,23 +456,31 @@ export default class TxController {
if (selected !== this.selectedTx) {
if (this.selectedTx) this.selectedTx.hoverOff()
if (selected) selected.hoverOn()
+ } else if (selected) {
+ selected.hoverRefresh()
}
this.selectedTx = selected
selectedTx.set(this.selectedTx)
}
}
- async mouseClick (position) {
+ async mouseClick (position, drop = false) {
if (this.poolScene) {
let selected = this.poolScene.selectAt(position)
if (!selected && this.blockScene && !this.explorerBlock && !this.blockScene.hidden) selected = this.blockScene.selectAt(position)
if (!selected && this.explorerBlockScene && this.explorerBlock && !this.explorerBlockScene.hidden) selected = this.explorerBlockScene.selectAt(position)
+ if (drop && selected && selected.state === 'pool') {
+ this.dropTx(selected.id)
+ return
+ }
let sameTx = true
if (selected !== this.selectedTx) {
sameTx = false
if (this.selectedTx) this.selectedTx.hoverOff()
if (selected) selected.hoverOn()
+ } else if (selected) {
+ selected.hoverRefresh()
}
this.selectedTx = selected
selectedTx.set(selected)
diff --git a/client/src/controllers/TxStream.js b/client/src/controllers/TxStream.js
index a688075..7207fdf 100644
--- a/client/src/controllers/TxStream.js
+++ b/client/src/controllers/TxStream.js
@@ -96,6 +96,10 @@ class TxStream {
this.websocket.send("block_id")
}
+ sendMempoolCountRequest () {
+ this.websocket.send("count")
+ }
+
disconnect () {
console.log('disconnecting websocket')
if (this.websocket) {
@@ -117,6 +121,7 @@ class TxStream {
this.setDelay(0)
this.reconnectBackoff = 128
this.sendHeartbeat()
+ this.sendMempoolCountRequest()
this.sendBlockRequest()
}
@@ -170,8 +175,8 @@ class TxStream {
break;
}
- // all events can include a count field, with the latest mempool size
- if (msg.count) window.dispatchEvent(new CustomEvent('bitcoin_mempool_count', { detail: msg.count }))
+ // all events can include count/vbytes fields, with the latest mempool size
+ if (msg.count != null) window.dispatchEvent(new CustomEvent('bitcoin_mempool_count', { detail: { count: msg.count, vbytes: msg.vbytes || 0 } }))
} catch (err) {
console.log('error parsing msg json: ', err)
}
diff --git a/client/src/models/BitcoinTx.js b/client/src/models/BitcoinTx.js
index 133d8e8..d48089d 100644
--- a/client/src/models/BitcoinTx.js
+++ b/client/src/models/BitcoinTx.js
@@ -147,26 +147,67 @@ export default class BitcoinTx {
}
hoverOn (color = bluegreen) {
- if (this.view) this.view.setHover(true, color)
+ if (this.view) this.view.setHover(true, color, this.hoverLens())
}
hoverOff () {
if (this.view) this.view.setHover(false)
}
+ hoverRefresh () {
+ if (this.view) this.view.refreshHover()
+ }
+
+ hoverLens () {
+ const radius = this.screenPosition && this.screenPosition.r
+ if (!radius) return null
+ const sizeLevel = this.gridPosition && this.gridPosition.r
+ const scale = sizeLevel <= 1 ? 3 : Math.max(1.2, 1 + 1.6 / sizeLevel)
+ return {
+ x: this.screenPosition.x,
+ y: this.screenPosition.y,
+ baseR: radius,
+ r: radius * scale
+ }
+ }
+
highlightOn (color = pink) {
if (this.view) this.view.setHighlight(true, color)
this.highlight = true
+ this.highlightColor = color
}
highlightOff () {
if (this.view) this.view.setHighlight(false)
this.highlight = false
+ this.highlightColor = null
+ }
+
+ focusPulse () {
+ const radius = this.screenPosition && this.screenPosition.r
+ if (!this.view || !this.view.initialised || !radius) return false
+ const pulseRadius = Math.min(Math.max(radius * 2.3, radius + 8), radius + 32)
+ this.view.update({
+ display: {
+ position: {
+ r: pulseRadius
+ },
+ color: {
+ alpha: 1
+ }
+ },
+ duration: 750,
+ delay: 0,
+ smooth: true,
+ boomerang: true
+ })
+ return true
}
applyHighlighting (criteria) {
let color
this.highlight = false
+ this.highlightColor = null
criteria.forEach(criterion => {
if (criterion.txid === this.id) {
this.highlight = true
@@ -180,6 +221,7 @@ export default class BitcoinTx {
})
}
})
+ if (this.highlight) this.highlightColor = color || pink
this.view.setHighlight(this.highlight, color || pink)
}
diff --git a/client/src/models/TxBlockScene.js b/client/src/models/TxBlockScene.js
index bb922f5..da77967 100644
--- a/client/src/models/TxBlockScene.js
+++ b/client/src/models/TxBlockScene.js
@@ -19,6 +19,9 @@ export default class TxBlockScene extends TxMondrianPoolScene {
this.initialised = true
this.inverted = true
this.hidden = false
+ this.opacity = 0.21
+ this.building = false
+ this.buildTimers = []
this.sceneType = 'block'
}
@@ -84,7 +87,10 @@ export default class TxBlockScene extends TxMondrianPoolScene {
tx.view.update({
display: {
position: tx.screenPosition,
- color: tx.getColor('block', this.colorMode).color
+ color: {
+ ...tx.getColor('block', this.colorMode).color,
+ alpha: 0
+ }
},
duration: 0,
delay: 0,
@@ -94,7 +100,10 @@ export default class TxBlockScene extends TxMondrianPoolScene {
tx.view.update({
display: {
position: tx.screenPosition,
- color: tx.getColor('block', this.colorMode).color
+ color: {
+ ...tx.getColor('block', this.colorMode).color,
+ alpha: this.building ? 1 : this.opacity
+ }
},
duration: this.laidOut ? 1000 : 2000,
delay: 200,
@@ -105,7 +114,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
}
- prepareTxOnScreen (tx, now) {
+ prepareTxOnScreen (tx, now, replay=false) {
const oldRadius = tx.pixelPosition.r
this.saveGridToPixelPosition(tx)
if (!tx.view.initialised) {
@@ -125,6 +134,23 @@ export default class TxBlockScene extends TxMondrianPoolScene {
state: 'ready'
})
} else {
+ const replayPosition = replay ? this.replayStartPosition(tx) : null
+ if (replay && replayPosition) {
+ tx.view.update({
+ display: {
+ position: replayPosition,
+ color: {
+ ...ice(tx.colors[this.colorMode].block.color),
+ alpha: 1
+ }
+ },
+ start: now,
+ delay: 0,
+ duration: 750,
+ smooth: true,
+ state: 'ready'
+ })
+ }
const jitter = (Math.random() * 1500)
tx.view.update({
display: {
@@ -149,9 +175,40 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
}
- prepareTx (tx, sequence) {
+ replayStartPosition (tx) {
+ const radius = Math.max(1, tx.pixelPosition.r || tx.screenPosition.r || 1)
+ const minY = radius + 24
+ const maxY = Math.max(minY, Math.min(window.innerHeight * 0.32, this.scene.offset.y - radius - 24))
+
+ return {
+ x: radius + (Math.random() * Math.max(1, window.innerWidth - (radius * 2))),
+ y: minY + (Math.random() * Math.max(1, maxY - minY)),
+ r: radius
+ }
+ }
+
+ prepareTx (tx, now, replay=false) {
this.place(tx)
- this.prepareTxOnScreen(tx)
+ this.prepareTxOnScreen(tx, now, replay)
+ }
+
+ setOpacity (opacity, duration=250) {
+ this.opacity = opacity
+ if (this.hidden || this.building) return
+
+ const ids = this.getActiveTxList()
+ for (let i = 0; i < ids.length; i++) {
+ this.txs[ids[i]].view.update({
+ display: {
+ color: {
+ alpha: opacity
+ }
+ },
+ duration,
+ delay: 0,
+ state: 'block'
+ })
+ }
}
enterTx (tx, start, right) {
@@ -175,7 +232,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
position: tx.screenPosition,
color: {
...tx.getColor('block', this.colorMode).color,
- alpha: 1
+ alpha: this.opacity
}
},
start,
@@ -196,6 +253,19 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
}
+ async enterAsync (right) {
+ this.hidden = false
+ this.exited = false
+ const ids = this.getActiveTxList()
+ const start = performance.now()
+ for (let i = 0; i < ids.length; i++) {
+ this.enterTx(this.txs[ids[i]], start, right)
+ if (i > 0 && i % 1500 === 0) {
+ await new Promise(resolve => requestAnimationFrame(resolve))
+ }
+ }
+ }
+
enterRight () {
this.enter(true)
}
@@ -209,7 +279,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
display: {
position: {
x: tx.screenPosition.x + (right ? window.innerWidth : -window.innerWidth) + ((Math.random()-0.5) * (window.innerHeight/4)),
- y: tx.screenPosition.y + ((Math.random()-0.5) * (window.innerHeight/4)),
+ y: tx.screenPosition.y,
r: tx.pixelPosition.r
},
color: {
@@ -235,6 +305,19 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
}
+ async exitAsync (right) {
+ this.hidden = true
+ this.exited = true
+ const ids = this.getActiveTxList()
+ const start = performance.now()
+ for (let i = 0; i < ids.length; i++) {
+ this.exitTx(this.txs[ids[i]], start, right)
+ if (i > 0 && i % 1500 === 0) {
+ await new Promise(resolve => requestAnimationFrame(resolve))
+ }
+ }
+ }
+
exitRight () {
this.exit(true)
}
@@ -270,7 +353,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
y: tx.screenPosition.y
},
color: {
- alpha: 1
+ alpha: this.opacity
}
},
start: now,
@@ -281,7 +364,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
})
}
- prepareAll () {
+ prepareAll (replay=false) {
const now = performance.now()
this.resize({})
this.scene.count = 0
@@ -292,7 +375,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
ids = this.getActiveTxList()
for (let i = 0; i < ids.length; i++) {
- this.prepareTx(this.txs[ids[i]], now)
+ this.prepareTx(this.txs[ids[i]], now, replay)
}
}
@@ -303,14 +386,43 @@ export default class TxBlockScene extends TxMondrianPoolScene {
// }
}
- initialLayout (exited) {
- this.prepareAll()
- setTimeout(() => {
+ clearBuildTimers () {
+ this.buildTimers.forEach(timer => clearTimeout(timer))
+ this.buildTimers = []
+ }
+
+ setBuildTimer (callback, delay) {
+ const timer = setTimeout(() => {
+ this.buildTimers = this.buildTimers.filter(item => item !== timer)
+ callback()
+ }, delay)
+ this.buildTimers.push(timer)
+ }
+
+ build (exited=false, replay=false) {
+ this.clearBuildTimers()
+ this.hidden = false
+ this.laidOut = false
+ this.building = true
+ this.prepareAll(replay)
+ this.setBuildTimer(() => {
this.layoutAll()
if (exited) this.exitRight()
+ this.setBuildTimer(() => {
+ this.building = false
+ this.setOpacity(this.opacity, 1200)
+ }, 3900)
}, 3000)
}
+ initialLayout (exited) {
+ this.build(exited, false)
+ }
+
+ replayBuild () {
+ this.build(false, true)
+ }
+
resetScroll () {
return
}
@@ -336,6 +448,7 @@ export default class TxBlockScene extends TxMondrianPoolScene {
}
expire (delay=3000) {
+ this.clearBuildTimers()
this.expired = true
const txIds = this.getTxList()
for (let i = 0; i < txIds.length; i++) {
diff --git a/client/src/models/TxMondrianPoolScene.js b/client/src/models/TxMondrianPoolScene.js
index 7ac8ea0..e11811c 100644
--- a/client/src/models/TxMondrianPoolScene.js
+++ b/client/src/models/TxMondrianPoolScene.js
@@ -10,8 +10,8 @@ settings.subscribe(v => {
})
export default class TxMondrianPoolScene extends TxPoolScene {
- constructor ({ width, height, unit, padding, controller, heightStore, colorMode }) {
- super({ width, height, unit, padding, controller, heightStore, colorMode })
+ constructor ({ width, height, unit, padding, controller, heightStore, leftStore, colorMode }) {
+ super({ width, height, unit, padding, controller, heightStore, leftStore, colorMode })
}
resize ({ width, height, unit, padding }) {
diff --git a/client/src/models/TxPoolScene.js b/client/src/models/TxPoolScene.js
index fc602b1..4e35b75 100644
--- a/client/src/models/TxPoolScene.js
+++ b/client/src/models/TxPoolScene.js
@@ -1,10 +1,12 @@
import config from '../config.js'
+import TxSprite from './TxSprite.js'
export default class TxPoolScene {
- constructor ({ width, height, unit, padding, controller, heightStore, colorMode }) {
+ constructor ({ width, height, unit, padding, controller, heightStore, leftStore, colorMode }) {
this.colorMode = colorMode || "age"
this.maxHeight = 0
this.heightStore = heightStore
+ this.leftStore = leftStore
this.sceneType = 'pool'
this.init({ width, height, unit, padding, controller })
}
@@ -44,6 +46,7 @@ export default class TxPoolScene {
this.scene.offset.x = (window.innerWidth - (this.blockWidth * this.gridSize)) / 2
this.scene.offset.y = (window.innerHeight - (this.blockHeight * this.gridSize)) / 2
+ if (this.leftStore) this.leftStore.set(this.scene.offset.x)
}
setColorMode (mode) {
@@ -184,18 +187,108 @@ export default class TxPoolScene {
this.scroll(this.heightLimit - bottom)
}
+ entryAnimation (tx, insertDelay=0) {
+ const weight = Math.min(1, tx.pixelPosition.r / 22)
+ const spawnTopTwoThirds = window.innerHeight * 2 / 3
+ const spawnX = Math.random() * window.innerWidth
+ const spawnY = window.innerHeight - (Math.random() * spawnTopTwoThirds)
+ const growRadius = tx.screenPosition.r * 0.3
+
+ return {
+ start: {
+ x: spawnX,
+ y: spawnY,
+ r: 0
+ },
+ grow: {
+ x: spawnX,
+ y: spawnY,
+ r: growRadius
+ },
+ delay: insertDelay + (Math.random() * 2200),
+ growDuration: 900 + (Math.random() * 500),
+ duration: 1600 + ((1 - weight) * 450) + (Math.random() * 450)
+ }
+ }
+
+ clearEntryTrail (tx) {
+ if (!tx || !tx.entryTrail) return
+ tx.entryTrail.timers.forEach(timer => clearTimeout(timer))
+ tx.entryTrail.sprites.forEach(sprite => sprite.destroy())
+ tx.entryTrail = null
+ }
+
+ clearEntryTrails () {
+ Object.values(this.txs).forEach(tx => this.clearEntryTrail(tx))
+ Object.values(this.hiddenTxs).forEach(tx => this.clearEntryTrail(tx))
+ }
+
+ createEntryTrail (tx, txColor, entry) {
+ if (!this.controller.showGhostTrails) return
+ const vertexArray = this.controller.trailVertexArray
+ if (!vertexArray || !tx.screenPosition.r) return
+
+ this.clearEntryTrail(tx)
+ tx.entryTrail = { sprites: [], timers: [] }
+
+ const schedule = (callback, delay) => {
+ const timer = setTimeout(() => {
+ if (!tx.entryTrail) return
+ tx.entryTrail.timers = tx.entryTrail.timers.filter(item => item !== timer)
+ callback()
+ }, delay)
+ tx.entryTrail.timers.push(timer)
+ }
+
+ for (let i = 0; i < 3; i++) {
+ const lag = 90 + (i * 105)
+ const alpha = 0.16 - (i * 0.035)
+ const radius = Math.max(1, tx.screenPosition.r * (0.9 - (i * 0.12)))
+
+ schedule(() => {
+ if (!this.txs[tx.id] || !tx.view || !tx.view.initialised) return
+ const sprite = new TxSprite({
+ x: entry.grow.x,
+ y: entry.grow.y,
+ r: Math.max(1, entry.grow.r * 0.8),
+ h: txColor.color.h,
+ l: txColor.color.l,
+ alpha
+ }, vertexArray)
+ tx.entryTrail.sprites.push(sprite)
+ sprite.update({
+ x: tx.screenPosition.x,
+ y: tx.screenPosition.y,
+ r: radius,
+ duration: entry.duration + (i * 140),
+ delay: 0,
+ smooth: true
+ })
+ schedule(() => {
+ if (!tx.entryTrail || !tx.entryTrail.sprites.includes(sprite)) return
+ sprite.update({
+ alpha: 0,
+ duration: 420,
+ delay: 0,
+ smooth: true
+ })
+ }, Math.max(300, entry.duration * 0.55))
+ }, entry.delay + entry.growDuration + lag)
+ }
+
+ schedule(() => this.clearEntryTrail(tx), entry.delay + entry.growDuration + entry.duration + 1000)
+ }
+
setTxOnScreen (tx, insertDelay=0) {
this.saveGridToPixelPosition(tx)
this.savePixelsToScreenPosition(tx)
if (!tx.view.initialised) {
const txColor = tx.getColor(this.sceneType, this.colorMode)
+ const entry = this.entryAnimation(tx, insertDelay)
+ const start = performance.now()
tx.view.update({
display: {
- position: this.pixelsToScreen({
- x: tx.pixelPosition.x,
- y: window.innerHeight + 10,
- r: this.unitWidth / 2
- }),
+ position: entry.start,
color: {
...txColor.color,
alpha: 1
@@ -204,15 +297,49 @@ export default class TxPoolScene {
delay: 0,
state: 'ready'
})
+ this.createEntryTrail(tx, txColor, entry)
tx.view.update({
display: {
- position: tx.screenPosition,
- color: txColor.color
+ position: entry.grow
},
- duration: 2500,
- delay: insertDelay,
+ start,
+ duration: entry.growDuration,
+ delay: entry.delay,
+ smooth: true,
state: 'pool'
})
+ // TxSprite stores one transition per attribute, so later phases must be scheduled after initial growth.
+ setTimeout(() => {
+ if (!this.txs[tx.id] || !tx.view || !tx.view.initialised) return
+ this.saveGridToPixelPosition(tx)
+ this.savePixelsToScreenPosition(tx)
+ tx.view.update({
+ display: {
+ position: tx.screenPosition
+ },
+ duration: entry.duration,
+ delay: 0,
+ smooth: true,
+ state: 'pool'
+ })
+ setTimeout(() => {
+ if (!this.txs[tx.id] || !tx.view || !tx.view.initialised) return
+ this.saveGridToPixelPosition(tx)
+ this.savePixelsToScreenPosition(tx)
+ tx.view.update({
+ display: {
+ position: {
+ r: tx.screenPosition.r * 1.18
+ }
+ },
+ duration: 220,
+ delay: 0,
+ smooth: true,
+ boomerang: true,
+ state: 'pool'
+ })
+ }, entry.duration)
+ }, entry.delay + entry.growDuration)
if (txColor.endColor) {
tx.view.update({
display: {
@@ -284,7 +411,9 @@ export default class TxPoolScene {
}
remove (id) {
- let exists = !!this.txs[id]
+ const tx = this.txs[id]
+ let exists = !!tx
+ this.clearEntryTrail(tx)
delete this.txs[id]
return exists
}
diff --git a/client/src/models/TxSprite.js b/client/src/models/TxSprite.js
index d744cac..e3a2f5a 100644
--- a/client/src/models/TxSprite.js
+++ b/client/src/models/TxSprite.js
@@ -29,9 +29,7 @@ function interpolateAttributeStart(attribute, now, modular) {
delta = 2 - delta
}
}
- if (attribute.e) {
- delta = smootherstep(delta)
- }
+ if (attribute.e) delta = attribute.e === 'in' ? delta * delta * delta : smootherstep(delta)
if (modular && Math.abs(attribute.a - attribute.b) > 0.5) {
if (attribute.a > 0.5) {
attribute.a -= 1
@@ -51,9 +49,10 @@ function interpolateAttributeStart(attribute, now, modular) {
export default class TxSprite {
- constructor({ now = performance.now(), x, y, r, h, l, alpha }, vertexArray) {
+ constructor({ now = performance.now(), x, y, r, h, l, alpha }, vertexArray, counted = true) {
const offsetTime = now
this.vertexArray = vertexArray
+ this.counted = counted
this.vertexData = Array(VI.length).fill(0)
this.updateMap = {
x: 0, y: 0, r: 0, h: 0, l: 0, a: 0
@@ -71,7 +70,7 @@ export default class TxSprite {
// Used to temporarily modify the sprite, so that the base view can be resumed later
this.modAttributes = null
- this.vertexPointer = this.vertexArray.insert(this)
+ this.vertexPointer = this.vertexArray.insert(this, counted)
this.compile()
}
@@ -99,7 +98,7 @@ export default class TxSprite {
attributes[key].b = updateMap[key]
if (!adjust || !inProgress) {
- if (smooth) attributes[key].e = true
+ if (smooth) attributes[key].e = smooth
else if (!smooth && attributes[key].e) delete attributes[key].e
if (boomerang) attributes[key].boom = true
else if (!boomerang && attributes[key].boom) delete attributes[key].boom
@@ -137,6 +136,28 @@ export default class TxSprite {
this.compile()
}
+ getDisplay (now = performance.now()) {
+ const attributes = this.modAttributes ? {
+ ...this.attributes,
+ ...this.modAttributes
+ } : this.attributes
+
+ const current = {}
+ for (const key of Object.keys(this.attributes)) {
+ const attribute = { ...attributes[key] }
+ interpolateAttributeStart(attribute, now, key === 'h')
+ current[key] = attribute.a
+ }
+ return {
+ x: current.x,
+ y: current.y,
+ r: current.r,
+ h: current.h,
+ l: current.l,
+ alpha: current.a
+ }
+ }
+
// Transition from modified state back to base attributes
resume (duration, now = performance.now()) {
// If not in modified state, there's nothing to do
@@ -203,8 +224,14 @@ export default class TxSprite {
this.vertexPointer = index
}
+ bringToFront () {
+ if (this.vertexArray && this.vertexPointer != null && this.vertexArray.moveToFront) {
+ this.vertexArray.moveToFront(this.vertexPointer)
+ }
+ }
+
destroy () {
- this.vertexArray.remove(this.vertexPointer)
+ this.vertexArray.remove(this.vertexPointer, this.counted)
this.vertexPointer = null
}
}
diff --git a/client/src/models/TxView.js b/client/src/models/TxView.js
index 2843d52..a5307da 100644
--- a/client/src/models/TxView.js
+++ b/client/src/models/TxView.js
@@ -1,6 +1,10 @@
import TxSprite from './TxSprite.js'
const highlightTransitionTime = 300
+const hoverGrowTransitionTime = 50
+const hoverShrinkTransitionTime = 1000
+const lensHaloPadding = 2.25
+const lensHaloAlpha = 0.55
// converts from this class's update format to TxSprite's update format
// now, id, value, position, size, color, alpha, duration, adjust
@@ -29,9 +33,16 @@ export default class TxView {
this.hover = false
this.highlight = false
+ this.lensSprite = null
+ this.lensHaloSprite = null
+ this.lensDestroyTimer = null
+ this.lensBaseRadius = 0
+ this.lensBoost = 0
+ this.lensGrowStartedAt = 0
}
destroy () {
+ this.destroyLens()
if (this.sprite) {
this.sprite.destroy()
this.sprite = null
@@ -61,14 +72,7 @@ export default class TxView {
this.vertexArray
)
// apply any pending modifications
- if (this.hover) {
- this.sprite.update({
- ...this.highlightColor,
- duration: highlightTransitionTime,
- adjust: false,
- modify: true
- })
- } else if (this.highlight) {
+ if (this.highlight) {
this.sprite.update({
...this.highlightColor,
duration: highlightTransitionTime,
@@ -81,21 +85,16 @@ export default class TxView {
toSpriteUpdate(display, duration, minDuration, delay, start, adjust, smooth, boomerang)
)
}
+ this.updateLensPosition(display && display.position, duration, delay, start, adjust, smooth)
}
- setHover (hoverOn, color) {
+ setHover (hoverOn, color, lens = null) {
if (hoverOn) {
this.hover = true
- this.hoverColor = color
- this.sprite.update({
- ...this.hoverColor,
- duration: highlightTransitionTime,
- adjust: false,
- modify: true,
- })
+ this.showLens(lens)
} else {
this.hover = false
- this.hoverColor = null
+ this.destroyLens(hoverShrinkTransitionTime)
if (this.highlight) {
if (this.sprite) {
this.sprite.update({
@@ -115,6 +114,7 @@ export default class TxView {
if (highlightOn) {
this.highlight = true
this.highlightColor = color
+ if (this.sprite) this.sprite.bringToFront()
if (!this.hover) {
if (this.sprite) {
this.sprite.update({
@@ -125,6 +125,7 @@ export default class TxView {
})
}
}
+ this.bringLensToFront()
} else {
this.highlight = false
this.highlightColor = null
@@ -137,4 +138,154 @@ export default class TxView {
getPosition () {
if (this.initialised && this.sprite) return this.sprite.getPosition()
}
+
+ showLens (lens) {
+ if (!lens || !this.vertexArray || !this.sprite) return
+ const display = this.sprite.getDisplay()
+
+ this.lensBoost = lens.r - lens.baseR
+ this.lensBaseRadius = lens.baseR
+ this.lensGrowStartedAt = performance.now()
+ if (this.lensDestroyTimer) clearTimeout(this.lensDestroyTimer)
+ this.lensDestroyTimer = null
+
+ if (!this.lensHaloSprite) {
+ this.lensHaloSprite = new TxSprite({
+ x: lens.x,
+ y: lens.y,
+ r: lens.baseR,
+ h: 0,
+ l: 0,
+ alpha: 0
+ }, this.vertexArray, false)
+ }
+
+ if (!this.lensSprite) {
+ this.lensSprite = new TxSprite({
+ x: lens.x,
+ y: lens.y,
+ r: lens.baseR,
+ h: display.h,
+ l: display.l,
+ alpha: 0
+ }, this.vertexArray, false)
+ }
+
+ this.bringLensToFront()
+
+ this.lensHaloSprite.update({
+ x: lens.x,
+ y: lens.y,
+ r: lens.r + lensHaloPadding,
+ h: 0,
+ l: 0,
+ alpha: lensHaloAlpha,
+ duration: hoverGrowTransitionTime,
+ adjust: false,
+ smooth: true
+ })
+
+ this.lensSprite.update({
+ x: lens.x,
+ y: lens.y,
+ r: lens.r,
+ h: display.h,
+ l: display.l,
+ alpha: display.alpha,
+ duration: hoverGrowTransitionTime,
+ adjust: false,
+ smooth: true
+ })
+ }
+
+ updateLensPosition (position, duration, delay, start, adjust, smooth) {
+ if ((!this.lensSprite && !this.lensHaloSprite) || !position) return
+
+ const update = {}
+ if (position.x != null) update.x = position.x
+ if (position.y != null) update.y = position.y
+ if (position.r != null) update.r = position.r + this.lensBoost
+ if (!Object.keys(update).length) return
+
+ const haloUpdate = { ...update }
+ if (haloUpdate.r != null) haloUpdate.r += lensHaloPadding
+
+ if (this.lensHaloSprite) this.lensHaloSprite.update({
+ ...haloUpdate,
+ start,
+ duration,
+ delay,
+ adjust,
+ smooth
+ })
+
+ if (this.lensSprite) this.lensSprite.update({
+ ...update,
+ start,
+ duration,
+ delay,
+ adjust,
+ smooth
+ })
+ if (this.hover) this.bringLensToFront()
+ }
+
+ refreshHover () {
+ if (this.hover) this.bringLensToFront()
+ }
+
+ bringLensToFront () {
+ if (this.vertexArray && this.vertexArray.moveGroupToFront && this.lensHaloSprite && this.lensSprite) {
+ this.vertexArray.moveGroupToFront([this.lensHaloSprite, this.lensSprite])
+ } else {
+ if (this.lensHaloSprite) this.lensHaloSprite.bringToFront()
+ if (this.lensSprite) this.lensSprite.bringToFront()
+ }
+ }
+
+ destroyLens (duration = 0) {
+ if (this.lensDestroyTimer) clearTimeout(this.lensDestroyTimer)
+ this.lensDestroyTimer = null
+ if (!this.lensSprite && !this.lensHaloSprite) return
+
+ const sprite = this.lensSprite
+ const haloSprite = this.lensHaloSprite
+ if (duration > 0) {
+ const growDelay = Math.max(0, hoverGrowTransitionTime - (performance.now() - this.lensGrowStartedAt))
+ if (growDelay > 0) {
+ this.lensDestroyTimer = setTimeout(() => {
+ this.lensDestroyTimer = null
+ if (!this.hover && this.lensSprite === sprite && this.lensHaloSprite === haloSprite) {
+ this.destroyLens(duration)
+ }
+ }, growDelay)
+ return
+ }
+ if (sprite) sprite.update({
+ r: this.lensBaseRadius,
+ alpha: 0,
+ duration,
+ adjust: false,
+ smooth: true
+ })
+ if (haloSprite) haloSprite.update({
+ r: this.lensBaseRadius + lensHaloPadding,
+ alpha: 0,
+ duration,
+ adjust: false,
+ smooth: true
+ })
+ this.lensDestroyTimer = setTimeout(() => {
+ if (this.lensSprite === sprite) this.lensSprite = null
+ if (this.lensHaloSprite === haloSprite) this.lensHaloSprite = null
+ if (sprite) sprite.destroy()
+ if (haloSprite) haloSprite.destroy()
+ }, duration + 50)
+ } else {
+ this.lensSprite = null
+ this.lensHaloSprite = null
+ if (sprite) sprite.destroy()
+ if (haloSprite) haloSprite.destroy()
+ }
+ }
}
diff --git a/client/src/stores.js b/client/src/stores.js
index ec8229d..62ac372 100644
--- a/client/src/stores.js
+++ b/client/src/stores.js
@@ -1,8 +1,6 @@
import { writable, derived } from 'svelte/store'
import { tweened } from 'svelte/motion';
import { makePollStore } from './utils/pollStore.js'
-import LocaleCurrency from 'locale-currency'
-import { currencies } from './utils/fx.js'
import config from './config.js'
function createCounter () {
@@ -54,6 +52,7 @@ function createCachedDict (namespace, setValues, defaultValues) {
// refresh exchange rates every minute
export const exchangeRates = makePollStore('rates', 'https://blockchain.info/ticker', 60000, {})
+export const priceChartChange = writable(null)
// refresh messages from donation server every hour
export const alerts = config.messagesEnabled ? makePollStore('alerts', `${config.donationRoot}/api/sponsorship/msgs.json`, 3600000, []) : writable(null)
// refresh sponsor data every 10 minutes
@@ -85,8 +84,10 @@ export const devEvents = writable({
export const txCount = createCounter()
export const lastBlockId = writable(null)
+export const replayBlockTrigger = createCounter()
export const mempoolCount = tweened(0)
export const mempoolScreenHeight = writable(0)
+export const mempoolScreenLeft = writable(0)
export const blockVisible = writable(false)
export const currentBlock = writable(null)
export const selectedTx = writable(null)
@@ -95,18 +96,17 @@ export const blockAreaSize = writable(0)
export const settingsOpen = writable(false)
-let localeCurrencyCode = LocaleCurrency.getCurrency(navigator.language)
-if (!currencies[localeCurrencyCode]) localeCurrencyCode = 'USD'
-
const defaultSettings = {
darkMode: true,
showNetworkStatus: true,
- currency: localeCurrencyCode,
+ currency: 'USD',
showFX: true,
+ priceChartMode: '30d',
vbytes: false,
- colorByFee: false,
- showMessages: true,
- showSearch: true,
+ colorByFee: true,
+ showGhostTrails: true,
+ showMessages: false,
+ showSearch: false,
noTrack: false,
blocksEnabled: true
}
@@ -121,7 +121,6 @@ const urlSettings = Object.keys(defaultSettings).reduce((map, key) => {
return map
}, {})
-if (urlSettings.showMessages == null) urlSettings.showMessages = true
if (urlSettings.blocksEnabled == null) urlSettings.blocksEnabled = true
export const settings = createCachedDict('settings', urlSettings, defaultSettings)
@@ -143,11 +142,14 @@ export const overlay = writable(null)
export const highlight = writable([])
export const newHighlightQuery = writable(null)
+export const removeHighlightQuery = writable(null)
+export const focusTx = writable(null)
export const highlightingFull = writable(false)
export const pageWidth = writable(window.innerWidth)
export const pageHeight = writable(window.innerHeight)
export const freezeResize = writable(false)
+export const fullscreenActive = writable(false)
let lastTinyScreen
export const tinyScreen = derived([pageWidth, pageHeight, freezeResize], ([$pageWidth, $pageHeight, $freezeResize]) => {
diff --git a/client/src/utils/format.js b/client/src/utils/format.js
index ba710a0..ea8a56e 100644
--- a/client/src/utils/format.js
+++ b/client/src/utils/format.js
@@ -48,3 +48,12 @@ export const durationFormat = {
else return relativeTimeFormat.format(Math.round(seconds / 60), Math.abs(Math.round(seconds / 60)) == 1 ? 'minute' : 'minutes')
}
}
+
+const blockVbytes = 1000000
+
+export function formatMempoolBlockEstimate (vbytes) {
+ if (vbytes <= 0) return null
+ if (vbytes < blockVbytes) return '<1 block'
+ const blocks = Math.ceil(vbytes / blockVbytes)
+ return `~${numberFormat.format(blocks)} block${blocks === 1 ? '' : 's'}`
+}
diff --git a/client/src/utils/fx.js b/client/src/utils/fx.js
index 78e5aaa..4bc2e51 100644
--- a/client/src/utils/fx.js
+++ b/client/src/utils/fx.js
@@ -239,7 +239,6 @@ export function formatCurrency (code, amount, params) {
const currency = currencies[code] || currencies.USD
let parts = [currency.char]
if (params && params.compact) {
- let compacted = amount
let suffixIndex = 0
while (amount > 1000 && suffixIndex < 4) {
amount /= 1000
@@ -249,7 +248,9 @@ export function formatCurrency (code, amount, params) {
if (suffixIndex == 0 && amount >= 10 && amount < 100) precision = 4
else precision = 3
- const amountPart = amount < 1000 ? amount.toPrecision(precision) : Math.round(amount)
+ const amountPart = amount < 1000
+ ? amount.toLocaleString(undefined, { minimumSignificantDigits: precision, maximumSignificantDigits: precision })
+ : Math.round(amount).toLocaleString()
parts.push(`${amountPart}${['','K','M','B','T'][suffixIndex]}`)
} else {
parts.push(amount.toLocaleString(undefined, { minimumFractionDigits: currency.dp, maximumFractionDigits: currency.dp }))
diff --git a/client/src/utils/memory.js b/client/src/utils/memory.js
index 5423334..3898100 100644
--- a/client/src/utils/memory.js
+++ b/client/src/utils/memory.js
@@ -28,10 +28,12 @@ export class FastVertexArray {
// console.log(this.data)
}
- insert (sprite) {
+ insert (sprite, counted = true) {
// console.log('inserting into FVA')
- this.count++
- if (this.counter) this.counter.increment()
+ if (counted) {
+ this.count++
+ if (this.counter) this.counter.increment()
+ }
let position
if (this.freeSlots.length) {
@@ -48,9 +50,11 @@ export class FastVertexArray {
return position
}
- remove (index) {
- this.count--
- if (this.counter) this.counter.decrement()
+ remove (index, counted = true) {
+ if (counted) {
+ this.count--
+ if (this.counter) this.counter.decrement()
+ }
this.setData(index, this.nullSprite)
this.freeSlots.push(index)
this.sprites[index] = null
@@ -64,6 +68,64 @@ export class FastVertexArray {
// this.print()
}
+ moveToFront (index) {
+ const sprite = this.sprites[index]
+ if (!sprite) return index
+
+ let target = this.lastSlot - 1
+ while (target > index && !this.sprites[target]) target--
+ if (target <= index) return index
+
+ const other = this.sprites[target]
+ this.sprites[target] = sprite
+ this.sprites[index] = other
+ sprite.moveVertexPointer(target)
+ other.moveVertexPointer(index)
+ sprite.compile()
+ other.compile()
+ return target
+ }
+
+ moveGroupToFront (sprites) {
+ const group = sprites.filter(sprite => (
+ sprite &&
+ sprite.vertexPointer != null &&
+ this.sprites[sprite.vertexPointer] === sprite
+ ))
+ if (!group.length) return null
+
+ const groupSet = new Set(group)
+ const targetSlots = []
+ for (let index = this.lastSlot - 1; index >= 0 && targetSlots.length < group.length; index--) {
+ if (this.sprites[index]) targetSlots.unshift(index)
+ }
+
+ const targetSet = new Set(targetSlots)
+ const sourceSlots = group.map(sprite => sprite.vertexPointer)
+ const displaced = targetSlots
+ .map(slot => this.sprites[slot])
+ .filter(sprite => sprite && !groupSet.has(sprite))
+ const vacatedSlots = sourceSlots.filter(slot => !targetSet.has(slot))
+ if (displaced.length !== vacatedSlots.length) return null
+
+ const moves = [
+ ...displaced.map((sprite, index) => [sprite, vacatedSlots[index]]),
+ ...group.map((sprite, index) => [sprite, targetSlots[index]])
+ ]
+
+ moves.forEach(([sprite, slot]) => {
+ this.sprites[slot] = sprite
+ })
+ moves.forEach(([sprite, slot]) => {
+ if (sprite.vertexPointer !== slot) {
+ sprite.moveVertexPointer(slot)
+ sprite.compile()
+ }
+ })
+
+ return targetSlots[targetSlots.length - 1]
+ }
+
getData (index) {
return this.data.subarray(index, this.stride)
}
diff --git a/client/src/utils/pollStore.js b/client/src/utils/pollStore.js
index 0e193ce..34bac6b 100644
--- a/client/src/utils/pollStore.js
+++ b/client/src/utils/pollStore.js
@@ -4,12 +4,14 @@ export function makePollStore (name, url, frequency, initialValue={}, responseHa
let interval, timer
const { subscribe, set, update } = writable(initialValue)
if (!responseHandler) responseHandler = async (response, set) => {
- const data = await response.json()
+ const body = await response.text()
+ if (!body) return
+ const data = JSON.parse(body)
if (data) set(data)
}
const fetcher = () => {
- fetch(`${url}?t=${Date.now()}`).then(response => { responseHandler(response, set) }).catch(error => {
+ fetch(`${url}?t=${Date.now()}`).then(response => responseHandler(response, set)).catch(error => {
console.log(`error polling data for ${name}: `, error)
if (timer) clearTimeout(timer)
timer = setTimeout(fetcher, 5000)
diff --git a/client/src/utils/search.js b/client/src/utils/search.js
index 7c08f37..6b9c6f8 100644
--- a/client/src/utils/search.js
+++ b/client/src/utils/search.js
@@ -138,7 +138,8 @@ async function fetchTx (txid) {
}
async function fetchBlockByHash (hash) {
- if (!hash || (currentBlockVal && hash === currentBlockVal.id)) return true
+ if (!hash) return true
+ if (currentBlockVal && hash === currentBlockVal.id) return currentBlockVal
// try to fetch static block
console.log('downloading block', hash)
let response = await fetch(`${api.uri}/api/block/${hash}`, {
@@ -179,6 +180,7 @@ async function fetchBlockByHeight (height) {
throw new Error(response.status)
}
}
+export {fetchBlockByHeight as fetchBlockByHeight}
async function fetchSpends (txid) {
if (txid == null) return
diff --git a/server/lib/block_data.ex b/server/lib/block_data.ex
index b906696..0c9007c 100644
--- a/server/lib/block_data.ex
+++ b/server/lib/block_data.ex
@@ -12,18 +12,60 @@ defmodule BitcoinStream.BlockData do
use GenServer
use Task, restart: :transient
+ alias BitcoinStream.RPC, as: RPC
+
def start_link(opts) do
Logger.info("Starting block data link");
- # load block
+ GenServer.start_link(__MODULE__, load_state(), opts)
+ end
+
+ @doc false
+ def load_state(read_cache \\ &read_cached_block/0, fetch_hash \\ &fetch_tip_hash/0) do
+ case read_cache.() do
+ {:ok, json} ->
+ case state_from_json(json) do
+ {:ok, state} -> state
+ _ -> state_from_tip(fetch_hash)
+ end
+
+ _ -> state_from_tip(fetch_hash)
+ end
+ end
- with {:ok, json} <- File.read("data/last_block.json"),
- {:ok, %{"id" => id}} <- Jason.decode(json) do
- GenServer.start_link(__MODULE__, {id, json}, opts)
+ @doc false
+ def state_from_json(json) do
+ with {:ok, block} <- Jason.decode(json),
+ id when is_binary(id) and id != "" <- block_id(block) do
+ {:ok, {id, json}}
else
- _ -> GenServer.start_link(__MODULE__, {nil, "null"}, opts)
+ _ -> :error
end
end
+ defp read_cached_block do
+ File.read("data/last_block.json")
+ end
+
+ defp state_from_tip(fetch_hash) do
+ case fetch_hash.() do
+ {:ok, hash} -> {hash, "null"}
+ _ -> {nil, "null"}
+ end
+ end
+
+ defp fetch_tip_hash do
+ case RPC.request(:rpc, "getbestblockhash", []) do
+ {:ok, 200, hash} when is_binary(hash) -> {:ok, hash}
+ err ->
+ Logger.info("Starting without cached block id: #{inspect(err)}")
+ :error
+ end
+ end
+
+ defp block_id(%{"id" => id}), do: id
+ defp block_id([_, id | _]), do: id
+ defp block_id(_), do: nil
+
@impl true
def init(state) do
{:ok, state}
diff --git a/server/lib/bridge_block.ex b/server/lib/bridge_block.ex
index 7425214..18b8982 100644
--- a/server/lib/bridge_block.ex
+++ b/server/lib/bridge_block.ex
@@ -68,7 +68,8 @@ defmodule BitcoinStream.Bridge.Block do
end
defp send_block(block, count) do
- case Jason.encode(%{type: "block", block: %{id: block.id}, drop: count}) do
+ vbytes = Mempool.get_vbytes(:mempool)
+ case Jason.encode(%{type: "block", block: %{id: block.id}, drop: count, count: count, vbytes: vbytes}) do
{:ok, payload} ->
Registry.dispatch(Registry.BitcoinStream, "txs", fn(entries) ->
for {pid, _} <- entries do
diff --git a/server/lib/bridge_sequence.ex b/server/lib/bridge_sequence.ex
index 8e32f89..8ef38bc 100644
--- a/server/lib/bridge_sequence.ex
+++ b/server/lib/bridge_sequence.ex
@@ -68,7 +68,8 @@ defmodule BitcoinStream.Bridge.Sequence do
defp send_txn(txn, count) do
# Logger.info("Forwarding transaction to websocket clients")
- case Jason.encode(%{type: "txn", txn: txn, count: count}) do
+ vbytes = Mempool.get_vbytes(:mempool)
+ case Jason.encode(%{type: "txn", txn: txn, count: count, vbytes: vbytes}) do
{:ok, payload} ->
Registry.dispatch(Registry.BitcoinStream, "txs", fn(entries) ->
for {pid, _} <- entries do
@@ -80,7 +81,8 @@ defmodule BitcoinStream.Bridge.Sequence do
end
defp send_drop_tx(txid, count) do
- case Jason.encode(%{type: "drop", txid: txid, count: count}) do
+ vbytes = Mempool.get_vbytes(:mempool)
+ case Jason.encode(%{type: "drop", txid: txid, count: count, vbytes: vbytes}) do
{:ok, payload} ->
Registry.dispatch(Registry.BitcoinStream, "txs", fn(entries) ->
for {pid, _} <- entries do
diff --git a/server/lib/bridge_tx.ex b/server/lib/bridge_tx.ex
index 3843e8b..b6c26a7 100644
--- a/server/lib/bridge_tx.ex
+++ b/server/lib/bridge_tx.ex
@@ -67,7 +67,8 @@ defmodule BitcoinStream.Bridge.Tx do
end
defp send_txn(txn, count) do
- case Jason.encode(%{type: "txn", txn: txn, count: count}) do
+ vbytes = Mempool.get_vbytes(:mempool)
+ case Jason.encode(%{type: "txn", txn: txn, count: count, vbytes: vbytes}) do
{:ok, payload} ->
Registry.dispatch(Registry.BitcoinStream, "txs", fn(entries) ->
for {pid, _} <- entries do
diff --git a/server/lib/mempool.ex b/server/lib/mempool.ex
index 8faade9..9824693 100644
--- a/server/lib/mempool.ex
+++ b/server/lib/mempool.ex
@@ -25,7 +25,7 @@ defmodule BitcoinStream.Mempool do
"""
def start_link(opts) do
Logger.info("Starting Mempool Tracker");
- # cache of all transactions in the node mempool, mapped to {inputs, total_input_value}
+ # cache of all transactions in the node mempool, mapped to {inputs, total_input_value, inflated, vbytes}
:ets.new(:mempool_cache, [:set, :public, :named_table]);
# cache of transactions ids in the mempool, but not yet synchronized with the :mempool_cache
:ets.new(:sync_cache, [:set, :public, :named_table]);
@@ -33,8 +33,8 @@ defmodule BitcoinStream.Mempool do
# used to avoid allowing confirmed transactions back into the mempool if rawtx events arrive late
:ets.new(:block_cache, [:set, :public, :named_table]);
- # state: {count, sequence_number, queue, done, blocklock}
- GenServer.start_link(__MODULE__, {0, :infinity, [], false, false}, opts)
+ # state: {count, vbytes, sequence_number, queue, done, blocklock}
+ GenServer.start_link(__MODULE__, {0, 0, :infinity, [], false, false}, opts)
end
@impl true
@@ -43,78 +43,106 @@ defmodule BitcoinStream.Mempool do
end
@impl true
- def handle_call(:get_count, _from, {count, seq, queue, done, blocklock}) do
- {:reply, count, {count, seq, queue, done, blocklock}}
+ def handle_call(:get_count, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, count, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call({:set_count, n}, _from, {_count, seq, queue, done, blocklock}) do
- {:reply, :ok, {n, seq, queue, done, blocklock}}
+ def handle_call(:get_vbytes, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, vbytes, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:increment_count, _from, {count, seq, queue, done, blocklock}) do
- {:reply, :ok, {count + 1, seq, queue, done, blocklock}}
+ def handle_call({:set_count, n}, _from, {_count, _vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {n, 0, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:decrement_count, _from, {count, seq, queue, done, blocklock}) do
- {:reply, :ok, {count - 1, seq, queue, done, blocklock}}
+ def handle_call({:set_stats, n, vbytes}, _from, {_count, _vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {n, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:get_seq, _from, {count, seq, queue, done, blocklock}) do
- {:reply, seq, {count, seq, queue, done, blocklock}}
+ def handle_call({:add_vbytes, n}, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {count, vbytes + n, seq, queue, done, blocklock}}
end
@impl true
- def handle_call({:set_seq, seq}, _from, {count, _seq, queue, done, blocklock}) do
- {:reply, :ok, {count, seq, queue, done, blocklock}}
+ def handle_call({:subtract_vbytes, n}, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {count, max(vbytes - n, 0), seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:get_queue, _from, {count, seq, queue, done, blocklock}) do
- {:reply, queue, {count, seq, queue, done, blocklock}}
+ def handle_call(:increment_count, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {count + 1, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call({:set_queue, queue}, _from, {count, seq, _queue, done, blocklock}) do
- {:reply, :ok, {count, seq, queue, done, blocklock}}
+ def handle_call(:decrement_count, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {count - 1, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call({:enqueue, txid}, _from, {count, seq, queue, done, blocklock}) do
- {:reply, :ok, {count, seq, [txid | queue], done, blocklock}}
+ def handle_call(:get_seq, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, seq, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:is_done, _from, {count, seq, queue, done, blocklock}) do
- {:reply, done, {count, seq, queue, done, blocklock}}
+ def handle_call({:set_seq, seq}, _from, {count, vbytes, _seq, queue, done, blocklock}) do
+ {:reply, :ok, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:set_done, _from, {count, seq, queue, _done, blocklock}) do
- {:reply, :ok, {count, seq, queue, true, blocklock}}
+ def handle_call(:get_queue, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, queue, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call(:is_block_locked, _from, {count, seq, queue, done, blocklock}) do
- {:reply, blocklock, {count, seq, queue, done, blocklock}}
+ def handle_call({:set_queue, queue}, _from, {count, vbytes, seq, _queue, done, blocklock}) do
+ {:reply, :ok, {count, vbytes, seq, queue, done, blocklock}}
end
@impl true
- def handle_call({:set_block_locked, lock}, _from, {count, seq, queue, done, _blocklock}) do
- {:reply, :ok, {count, seq, queue, done, lock}}
+ def handle_call({:enqueue, txid}, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, :ok, {count, vbytes, seq, [txid | queue], done, blocklock}}
+ end
+
+ @impl true
+ def handle_call(:is_done, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, done, {count, vbytes, seq, queue, done, blocklock}}
+ end
+
+ @impl true
+ def handle_call(:set_done, _from, {count, vbytes, seq, queue, _done, blocklock}) do
+ {:reply, :ok, {count, vbytes, seq, queue, true, blocklock}}
+ end
+
+ @impl true
+ def handle_call(:is_block_locked, _from, {count, vbytes, seq, queue, done, blocklock}) do
+ {:reply, blocklock, {count, vbytes, seq, queue, done, blocklock}}
+ end
+
+ @impl true
+ def handle_call({:set_block_locked, lock}, _from, {count, vbytes, seq, queue, done, _blocklock}) do
+ {:reply, :ok, {count, vbytes, seq, queue, done, lock}}
end
def set(pid, n) do
GenServer.call(pid, {:set_count, n})
end
+ def set(pid, n, vbytes) do
+ GenServer.call(pid, {:set_stats, n, vbytes})
+ end
+
def get(pid) do
GenServer.call(pid, :get_count)
end
+ def get_vbytes(pid) do
+ GenServer.call(pid, :get_vbytes)
+ end
+
defp increment(pid) do
GenServer.call(pid, :increment_count)
end
@@ -123,6 +151,20 @@ defmodule BitcoinStream.Mempool do
GenServer.call(pid, :decrement_count)
end
+ defp add_vbytes(pid, n) when is_number(n) do
+ GenServer.call(pid, {:add_vbytes, n})
+ end
+ defp add_vbytes(_pid, _n) do
+ :ok
+ end
+
+ defp subtract_vbytes(pid, n) when is_number(n) do
+ GenServer.call(pid, {:subtract_vbytes, n})
+ end
+ defp subtract_vbytes(_pid, _n) do
+ :ok
+ end
+
defp get_seq(pid) do
GenServer.call(pid, :get_seq)
end
@@ -159,6 +201,17 @@ defmodule BitcoinStream.Mempool do
GenServer.call(pid, {:set_block_locked, lock})
end
+ defp mempool_data(txn) do
+ {txn.inputs, txn.value + txn.fee, txn.inflated, txn.vbytes || 0}
+ end
+
+ defp mempool_data_vbytes({_inputs, _value, _inflated, vbytes}) do
+ vbytes
+ end
+ defp mempool_data_vbytes(_data) do
+ 0
+ end
+
def get_tx_status(_pid, txid) do
case :ets.lookup(:mempool_cache, txid) do
# new transaction, not yet registered
@@ -190,8 +243,10 @@ defmodule BitcoinStream.Mempool do
# new transaction, id already registered
:registered ->
with [] <- :ets.lookup(:block_cache, txid) do # double check tx isn't included in the last block
- :ets.insert(:mempool_cache, {txid, { txn.inputs, txn.value + txn.fee, txn.inflated }, nil});
+ data = mempool_data(txn);
+ :ets.insert(:mempool_cache, {txid, data, nil});
cache_spends(txid, txn.inputs);
+ add_vbytes(pid, mempool_data_vbytes(data));
get(pid)
else
_ ->
@@ -247,12 +302,14 @@ defmodule BitcoinStream.Mempool do
# data already received, but tx not registered
[{_txid, _, txn}] when txn != nil ->
- :ets.insert(:mempool_cache, {txid, { txn.inputs, txn.value + txn.fee, txn.inflated }, nil});
+ data = mempool_data(txn);
+ :ets.insert(:mempool_cache, {txid, data, nil});
:ets.delete(:sync_cache, txid);
cache_spends(txid, txn.inputs);
if do_count do
increment(pid);
end
+ add_vbytes(pid, mempool_data_vbytes(data));
{txn, get(pid)}
# some other invalid state (should never happen)
@@ -299,9 +356,10 @@ defmodule BitcoinStream.Mempool do
# tx fully processed and not already dropped
[{txid, data, _status}] when data != nil ->
:ets.delete(:mempool_cache, txid);
- {inputs, _value, _inflated} = data;
+ {inputs, _value, _inflated, _vbytes} = data;
uncache_spends(inputs);
decrement(pid);
+ subtract_vbytes(pid, mempool_data_vbytes(data));
get(pid)
_ -> false
@@ -310,7 +368,8 @@ defmodule BitcoinStream.Mempool do
defp send_mempool_count(pid) do
count = get(pid)
- case Jason.encode(%{type: "count", count: count}) do
+ vbytes = get_vbytes(pid)
+ case Jason.encode(%{type: "count", count: count, vbytes: vbytes}) do
{:ok, payload} ->
Registry.dispatch(Registry.BitcoinStream, "txs", fn(entries) ->
for {pid, _} <- entries do
@@ -360,11 +419,24 @@ defmodule BitcoinStream.Mempool do
def do_sync(pid, txns) do
Logger.info("Syncing #{length(txns)} mempool transactions");
sync_mempool(pid, txns);
+ sync_stats(pid);
Logger.info("MEMPOOL SYNC FINISHED");
set_done(pid);
+ send_mempool_count(pid);
:ok
end
+ def sync_stats(pid) do
+ with {:ok, 200, %{"size" => count, "bytes" => vbytes}} when is_integer(count) and is_integer(vbytes) <- RPC.request(:rpc, "getmempoolinfo", []) do
+ set(pid, count, vbytes)
+ else
+ err ->
+ Logger.error("mempool stats sync failed");
+ Logger.error("#{inspect(err)}");
+ :error
+ end
+ end
+
defp sync_mempool(pid, txns) do
sync_mempool_txns(pid, txns)
end
diff --git a/server/lib/mempool_sync.ex b/server/lib/mempool_sync.ex
index 57d0e69..6659cde 100644
--- a/server/lib/mempool_sync.ex
+++ b/server/lib/mempool_sync.ex
@@ -70,15 +70,14 @@ defmodule BitcoinStream.Mempool.Sync do
Process.send_after(self(), :resync, 5 * 1000)
false ->
- with {:ok, 200, %{"size" => size}} when is_integer(size) <- RPC.request(:rpc, "getmempoolinfo", []),
+ with {:ok, 200, %{"size" => size, "bytes" => bytes}} when is_integer(size) and is_integer(bytes) <- RPC.request(:rpc, "getmempoolinfo", []),
count when is_integer(count) <- Mempool.get(:mempool) do
Logger.debug("Mempool health check - Core count: #{size} | Bitfeed count: #{count}");
- # if we've diverged from the true count by more than 50 txs, then fix
- # ensures our count doesn't stray too far due to missed events & unexpected errors.
- if (abs(size - count) > 50) do
+ # If we've diverged from Core, repair both count and total virtual size.
+ if (abs(size - count) > 50 or abs(bytes - Mempool.get_vbytes(:mempool)) > 50_000) do
Logger.debug("resync");
- Mempool.set(:mempool, size);
+ Mempool.set(:mempool, size, bytes);
newcount = Mempool.get(:mempool);
Logger.debug("updated to #{newcount}");
end
diff --git a/server/lib/socket_handler.ex b/server/lib/socket_handler.ex
index 9d71ef5..a3414c8 100644
--- a/server/lib/socket_handler.ex
+++ b/server/lib/socket_handler.ex
@@ -35,7 +35,8 @@ defmodule BitcoinStream.SocketHandler do
def get_mempool_count_msg() do
count = Mempool.get(:mempool);
- "{ \"type\": \"count\", \"count\": #{count}}"
+ vbytes = Mempool.get_vbytes(:mempool);
+ "{ \"type\": \"count\", \"count\": #{count}, \"vbytes\": #{vbytes}}"
end
def get_block_id_msg() do
diff --git a/server/scripts/run-on-umbrel.sh b/server/scripts/run-on-umbrel.sh
new file mode 100755
index 0000000..32e78e1
--- /dev/null
+++ b/server/scripts/run-on-umbrel.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+source_tar="${1:-/home/umbrel/bitfeed-server-src.tar.gz}"
+build_dir="${BITFEED_BUILD_DIR:-/home/umbrel/bitfeed-server-build}"
+bitcoin_container="${BITCOIN_CONTAINER:-bitcoin_app_1}"
+name="${BITFEED_CONTAINER:-bitfeed-server}"
+port="${BITFEED_PORT:-5001}"
+
+sudo rm -rf "$build_dir"
+mkdir -p "$build_dir"
+tar -xzf "$source_tar" -C "$build_dir"
+sudo docker build -t bitfeed-server:umbrel "$build_dir"
+
+network="$(
+ sudo docker inspect "$bitcoin_container" \
+ --format '{{range $name, $_ := .NetworkSettings.Networks}}{{$name}}{{"\n"}}{{end}}' \
+ | head -n 1
+)"
+
+cookie="$(
+ sudo docker exec "$bitcoin_container" sh -lc '
+ for path in /data/.bitcoin/.cookie /bitcoin/.bitcoin/.cookie /home/bitcoin/.bitcoin/.cookie /data/bitcoin/.cookie; do
+ [ -f "$path" ] && printf "%s\n" "$path" && exit 0
+ done
+ find / -name .cookie 2>/dev/null | head -n 1
+ '
+)"
+
+if [ -z "$network" ] || [ -z "$cookie" ]; then
+ echo "Could not find bitcoin docker network or RPC cookie path" >&2
+ exit 1
+fi
+
+sudo docker rm -f "$name" >/dev/null 2>&1 || true
+
+sudo docker run -d \
+ --name "$name" \
+ --restart unless-stopped \
+ --network "$network" \
+ --volumes-from "$bitcoin_container":ro \
+ -p "$port:$port" \
+ -e PORT="$port" \
+ -e BITCOIN_HOST="$bitcoin_container" \
+ -e BITCOIN_RPC_PORT=8332 \
+ -e BITCOIN_RPC_COOKIE="$cookie" \
+ -e BITCOIN_ZMQ_RAWBLOCK_PORT=28332 \
+ -e BITCOIN_ZMQ_RAWTX_PORT=28333 \
+ -e BITCOIN_ZMQ_SEQUENCE_PORT=28335 \
+ -e LOG_LEVEL=info \
+ bitfeed-server:umbrel
+
+sudo docker logs --tail 80 "$name"
diff --git a/server/scripts/test-elixir11-container.sh b/server/scripts/test-elixir11-container.sh
new file mode 100755
index 0000000..f0ef2f9
--- /dev/null
+++ b/server/scripts/test-elixir11-container.sh
@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+root=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd)
+name="bitfeed-server-test-$$"
+
+cleanup() {
+ container stop "$name" >/dev/null 2>&1 || true
+ container delete "$name" >/dev/null 2>&1 || true
+}
+
+trap cleanup EXIT INT TERM
+
+container create --name "$name" --workdir /app elixir:1.11-slim sleep 600 >/dev/null
+container start "$name" >/dev/null
+container cp "$root/server" "$name:/app"
+
+container exec "$name" sh -lc '
+ mix local.hex --force &&
+ mix local.rebar --force &&
+ cd /app/server &&
+ mix deps.get &&
+ mix test "$@"
+' sh "$@"
diff --git a/server/test/block_data_test.exs b/server/test/block_data_test.exs
new file mode 100644
index 0000000..718a824
--- /dev/null
+++ b/server/test/block_data_test.exs
@@ -0,0 +1,32 @@
+defmodule BitcoinStream.BlockDataTest do
+ use ExUnit.Case
+
+ alias BitcoinStream.BlockData
+
+ test "loads cached block id from map json" do
+ json = ~s({"id":"abc"})
+
+ assert BlockData.state_from_json(json) == {:ok, {"abc", json}}
+ end
+
+ test "loads cached block id from compact block json" do
+ json = ~s([1,"abc",957000])
+
+ assert BlockData.state_from_json(json) == {:ok, {"abc", json}}
+ end
+
+ test "falls back to tip hash when cache is missing" do
+ assert BlockData.load_state(fn -> {:error, :enoent} end, fn -> {:ok, "tip"} end) ==
+ {"tip", "null"}
+ end
+
+ test "falls back to tip hash when cache has no usable id" do
+ assert BlockData.load_state(fn -> {:ok, ~s({"id":""})} end, fn -> {:ok, "tip"} end) ==
+ {"tip", "null"}
+ end
+
+ test "starts without block id when cache and tip lookup fail" do
+ assert BlockData.load_state(fn -> {:error, :enoent} end, fn -> :error end) ==
+ {nil, "null"}
+ end
+end
diff --git a/server/test/mempool_test.exs b/server/test/mempool_test.exs
new file mode 100644
index 0000000..9a0b517
--- /dev/null
+++ b/server/test/mempool_test.exs
@@ -0,0 +1,53 @@
+defmodule BitcoinStream.MempoolTest do
+ use ExUnit.Case
+
+ alias BitcoinStream.Mempool
+
+ setup do
+ for table <- [:mempool_cache, :sync_cache, :block_cache], :ets.whereis(table) != :undefined do
+ :ets.delete(table)
+ end
+
+ {:ok, pid} = Mempool.start_link([])
+ {:ok, pid: pid}
+ end
+
+ test "tracks vbytes when raw tx arrives after the sequence event", %{pid: pid} do
+ Mempool.set(pid, 1)
+ :ets.insert(:mempool_cache, {"tx1", nil, :ready})
+
+ assert Mempool.get_vbytes(pid) == 0
+ assert Mempool.insert(pid, "tx1", tx("tx1", 250)) == 1
+ assert Mempool.get_vbytes(pid) == 250
+ assert Mempool.drop(pid, "tx1") == 0
+ assert Mempool.get_vbytes(pid) == 0
+ end
+
+ test "sets count and vbytes from node mempool stats", %{pid: pid} do
+ assert Mempool.set(pid, 55_703, 31_000_000) == :ok
+ assert Mempool.get(pid) == 55_703
+ assert Mempool.get_vbytes(pid) == 31_000_000
+ end
+
+ test "tracks vbytes when raw tx arrives before the sequence event", %{pid: pid} do
+ mark_synced(pid)
+
+ assert Mempool.insert(pid, "tx1", tx("tx1", 400)) == false
+ assert Mempool.get_vbytes(pid) == 0
+
+ {txn, count} = Mempool.register(pid, "tx1", 1, true)
+ assert txn.id == "tx1"
+ assert count == 1
+ assert Mempool.get_vbytes(pid) == 400
+ end
+
+ defp mark_synced(pid) do
+ :sys.replace_state(pid, fn {count, vbytes, _seq, queue, done, blocklock} ->
+ {count, vbytes, 0, queue, done, blocklock}
+ end)
+ end
+
+ defp tx(id, vbytes) do
+ %{id: id, inputs: [], value: 1000, fee: 10, inflated: true, vbytes: vbytes}
+ end
+end