903 lines
16 KiB
JavaScript
903 lines
16 KiB
JavaScript
const http = require('http')
|
|
const net = require('net')
|
|
const {
|
|
checkPassword,
|
|
createSession,
|
|
isValidSession,
|
|
} = require('./auth')
|
|
const {
|
|
listAddresses,
|
|
addAddress,
|
|
removeAddress,
|
|
} = require('./addresses')
|
|
const {
|
|
addressToScriptPubKey,
|
|
scriptPubKeyToScripthash,
|
|
addressToScripthash,
|
|
} = require('./bitcoin-address')
|
|
const {
|
|
getTransaction,
|
|
} = require('./transactions')
|
|
|
|
const port = 8080
|
|
const fulcrumTimeoutMs = 3000
|
|
|
|
const fs = require('fs')
|
|
const path = require('path')
|
|
|
|
const addressCacheDir = '/data/cache/addresses'
|
|
const addressCacheMaxAgeMs = 60000
|
|
const addressRefreshes = new Map()
|
|
|
|
function ensureAddressCacheDir() {
|
|
fs.mkdirSync(addressCacheDir, {
|
|
recursive: true,
|
|
})
|
|
}
|
|
|
|
function getAddressCachePath(scripthash) {
|
|
return path.join(
|
|
addressCacheDir,
|
|
`${scripthash}.json`,
|
|
)
|
|
}
|
|
|
|
function readAddressCache(scripthash) {
|
|
try {
|
|
const cachePath =
|
|
getAddressCachePath(scripthash)
|
|
|
|
const stat = fs.statSync(cachePath)
|
|
|
|
const data =
|
|
JSON.parse(
|
|
fs.readFileSync(
|
|
cachePath,
|
|
'utf8',
|
|
),
|
|
)
|
|
|
|
if (
|
|
!data ||
|
|
typeof data !== 'object' ||
|
|
!data.address
|
|
) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
data,
|
|
ageMs: Math.max(
|
|
0,
|
|
Date.now() - stat.mtimeMs,
|
|
),
|
|
}
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
function writeAddressCache(data) {
|
|
try {
|
|
ensureAddressCacheDir()
|
|
|
|
const cachePath =
|
|
getAddressCachePath(
|
|
data.scripthash,
|
|
)
|
|
|
|
const tempPath =
|
|
`${cachePath}.${process.pid}.tmp`
|
|
|
|
fs.writeFileSync(
|
|
tempPath,
|
|
JSON.stringify(data),
|
|
'utf8',
|
|
)
|
|
|
|
fs.renameSync(
|
|
tempPath,
|
|
cachePath,
|
|
)
|
|
} catch (error) {
|
|
console.error(
|
|
'Failed to write address cache:',
|
|
error,
|
|
)
|
|
}
|
|
}
|
|
|
|
function refreshAddressCache(
|
|
address,
|
|
scripthash,
|
|
) {
|
|
const existing =
|
|
addressRefreshes.get(scripthash)
|
|
|
|
if (existing) {
|
|
return existing
|
|
}
|
|
|
|
const refresh =
|
|
getAddressDataFromFulcrum(
|
|
address,
|
|
scripthash,
|
|
)
|
|
.then((data) => {
|
|
writeAddressCache(data)
|
|
return data
|
|
})
|
|
.catch((error) => {
|
|
console.error(
|
|
`Failed to refresh address ${address}:`,
|
|
error,
|
|
)
|
|
|
|
throw error
|
|
})
|
|
.finally(() => {
|
|
addressRefreshes.delete(
|
|
scripthash,
|
|
)
|
|
})
|
|
|
|
addressRefreshes.set(
|
|
scripthash,
|
|
refresh,
|
|
)
|
|
|
|
return refresh
|
|
}
|
|
|
|
function queryFulcrum(fulcrumUrl, method, params = []) {
|
|
return new Promise((resolve) => {
|
|
if (!fulcrumUrl) {
|
|
resolve({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Fulcrum URL is not configured',
|
|
})
|
|
return
|
|
}
|
|
|
|
let parsed
|
|
|
|
try {
|
|
parsed = new URL(fulcrumUrl)
|
|
} catch {
|
|
resolve({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Invalid Fulcrum URL',
|
|
})
|
|
return
|
|
}
|
|
|
|
if (parsed.protocol !== 'tcp:') {
|
|
resolve({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Fulcrum URL must use tcp://',
|
|
})
|
|
return
|
|
}
|
|
|
|
const host = parsed.hostname
|
|
const fulcrumPort = Number(parsed.port)
|
|
|
|
if (!host || !fulcrumPort) {
|
|
resolve({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Fulcrum URL is missing host or port',
|
|
})
|
|
return
|
|
}
|
|
|
|
const socket = net.createConnection({
|
|
host,
|
|
port: fulcrumPort,
|
|
})
|
|
|
|
let response = ''
|
|
let settled = false
|
|
|
|
const finish = (value) => {
|
|
if (settled) return
|
|
|
|
settled = true
|
|
socket.destroy()
|
|
resolve(value)
|
|
}
|
|
|
|
socket.setTimeout(fulcrumTimeoutMs)
|
|
|
|
socket.on('connect', () => {
|
|
console.log(
|
|
`Fulcrum connected for ${method} (${host}:${fulcrumPort})`,
|
|
)
|
|
|
|
const request =
|
|
JSON.stringify({
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
method,
|
|
params,
|
|
}) + '\n'
|
|
|
|
console.log(`Sending Fulcrum request: ${request.trim()}`)
|
|
|
|
socket.write(request)
|
|
})
|
|
|
|
socket.on('data', (data) => {
|
|
const chunk = data.toString()
|
|
|
|
console.log(`Fulcrum response data: ${chunk.trim()}`)
|
|
|
|
response += chunk
|
|
|
|
const lines = response.split('\n')
|
|
|
|
for (const line of lines) {
|
|
if (!line.trim()) continue
|
|
|
|
let message
|
|
|
|
try {
|
|
message = JSON.parse(line)
|
|
} catch {
|
|
continue
|
|
}
|
|
|
|
if (message.error) {
|
|
console.error(
|
|
`Fulcrum returned an error for ${method}:`,
|
|
JSON.stringify(message.error),
|
|
)
|
|
|
|
finish({
|
|
ok: false,
|
|
result: null,
|
|
error: message.error,
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(
|
|
message,
|
|
'result',
|
|
)
|
|
) {
|
|
finish({
|
|
ok: true,
|
|
result: message.result,
|
|
error: null,
|
|
})
|
|
|
|
return
|
|
}
|
|
}
|
|
})
|
|
|
|
socket.on('timeout', () => {
|
|
console.error(
|
|
`Fulcrum request timed out after ${fulcrumTimeoutMs}ms: ${method}`,
|
|
)
|
|
|
|
finish({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Connection timed out',
|
|
})
|
|
})
|
|
|
|
socket.on('error', (error) => {
|
|
console.error(
|
|
`Fulcrum socket error for ${method}:`,
|
|
error.message,
|
|
)
|
|
|
|
finish({
|
|
ok: false,
|
|
result: null,
|
|
error: error.message,
|
|
})
|
|
})
|
|
|
|
socket.on('close', (hadError) => {
|
|
console.log(
|
|
`Fulcrum socket closed for ${method}; hadError=${hadError}`,
|
|
)
|
|
|
|
if (!settled) {
|
|
finish({
|
|
ok: false,
|
|
result: null,
|
|
error: 'Connection closed before a response was received',
|
|
})
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
async function getFulcrumStatus(fulcrumUrl) {
|
|
const version = await queryFulcrum(
|
|
fulcrumUrl,
|
|
'server.version',
|
|
['Munin Bitcoin', '1.4'],
|
|
)
|
|
|
|
if (!version.ok) {
|
|
return {
|
|
configured: Boolean(fulcrumUrl),
|
|
connected: false,
|
|
url: fulcrumUrl,
|
|
serverVersion: null,
|
|
blockchainHeight: null,
|
|
error: version.error,
|
|
}
|
|
}
|
|
|
|
const headers = await queryFulcrum(
|
|
fulcrumUrl,
|
|
'blockchain.headers.subscribe',
|
|
[],
|
|
)
|
|
|
|
return {
|
|
configured: Boolean(fulcrumUrl),
|
|
connected: true,
|
|
url: fulcrumUrl,
|
|
serverVersion: version.result,
|
|
blockchainHeight:
|
|
headers.ok && headers.result
|
|
? headers.result.height ?? null
|
|
: null,
|
|
error: headers.ok ? null : headers.error,
|
|
}
|
|
}
|
|
|
|
async function getStatus() {
|
|
const fulcrumUrl = process.env.MUNIN_FULCRUM_URL || null
|
|
const fulcrum = await getFulcrumStatus(fulcrumUrl)
|
|
|
|
return {
|
|
service: 'running',
|
|
fulcrum,
|
|
wallet: 'not configured',
|
|
labels: 0,
|
|
transactions: 0,
|
|
lastScan: 'never',
|
|
}
|
|
}
|
|
|
|
async function getAddressDataFromFulcrum(
|
|
address,
|
|
scripthash,
|
|
) {
|
|
const fulcrumUrl =
|
|
process.env.MUNIN_FULCRUM_URL || null
|
|
|
|
if (!fulcrumUrl) {
|
|
throw new Error(
|
|
'Fulcrum URL is not configured',
|
|
)
|
|
}
|
|
|
|
const balance = await queryFulcrum(
|
|
fulcrumUrl,
|
|
'blockchain.scripthash.get_balance',
|
|
[scripthash],
|
|
)
|
|
|
|
if (!balance.ok) {
|
|
throw new Error(
|
|
`Failed to query address balance: ${JSON.stringify(balance.error)}`,
|
|
)
|
|
}
|
|
|
|
const utxos = await queryFulcrum(
|
|
fulcrumUrl,
|
|
'blockchain.scripthash.listunspent',
|
|
[scripthash],
|
|
)
|
|
|
|
if (!utxos.ok) {
|
|
throw new Error(
|
|
`Failed to query address UTXOs: ${JSON.stringify(utxos.error)}`,
|
|
)
|
|
}
|
|
|
|
const history = await queryFulcrum(
|
|
fulcrumUrl,
|
|
'blockchain.scripthash.get_history',
|
|
[scripthash],
|
|
)
|
|
|
|
if (!history.ok) {
|
|
throw new Error(
|
|
`Failed to query address history: ${JSON.stringify(history.error)}`,
|
|
)
|
|
}
|
|
|
|
return {
|
|
address,
|
|
scripthash,
|
|
confirmedBalance:
|
|
Number(balance.result?.confirmed || 0),
|
|
unconfirmedBalance:
|
|
Number(balance.result?.unconfirmed || 0),
|
|
utxos:
|
|
Array.isArray(utxos.result)
|
|
? utxos.result
|
|
: [],
|
|
history:
|
|
Array.isArray(history.result)
|
|
? history.result
|
|
: [],
|
|
lastSynced:
|
|
new Date().toISOString(),
|
|
}
|
|
}
|
|
|
|
async function getAddressData(address) {
|
|
let scripthash
|
|
|
|
try {
|
|
scripthash =
|
|
addressToScripthash(address)
|
|
} catch (error) {
|
|
throw new Error(
|
|
error instanceof Error
|
|
? error.message
|
|
: 'Invalid Bitcoin address',
|
|
)
|
|
}
|
|
|
|
const cached =
|
|
readAddressCache(scripthash)
|
|
|
|
if (cached) {
|
|
if (
|
|
cached.ageMs >
|
|
addressCacheMaxAgeMs
|
|
) {
|
|
refreshAddressCache(
|
|
address,
|
|
scripthash,
|
|
).catch(() => {})
|
|
}
|
|
|
|
return {
|
|
...cached.data,
|
|
cacheAgeMs:
|
|
cached.ageMs,
|
|
}
|
|
}
|
|
|
|
const data =
|
|
await refreshAddressCache(
|
|
address,
|
|
scripthash,
|
|
)
|
|
|
|
return {
|
|
...data,
|
|
cacheAgeMs: 0,
|
|
}
|
|
}
|
|
|
|
async function getAddressesWithData() {
|
|
const addresses = await listAddresses()
|
|
const results = []
|
|
|
|
for (const entry of addresses) {
|
|
try {
|
|
const data = await getAddressData(entry.address)
|
|
|
|
results.push({
|
|
...entry,
|
|
scripthash: data.scripthash,
|
|
confirmedBalance: data.confirmedBalance,
|
|
unconfirmedBalance: data.unconfirmedBalance,
|
|
utxos: data.utxos,
|
|
history: data.history,
|
|
lastSynced:
|
|
data.lastSynced || null,
|
|
cacheAgeMs:
|
|
Number(data.cacheAgeMs || 0),
|
|
error: null,
|
|
})
|
|
} catch (error) {
|
|
results.push({
|
|
...entry,
|
|
confirmedBalance: null,
|
|
unconfirmedBalance: null,
|
|
utxos: [],
|
|
history: [],
|
|
lastSynced: null,
|
|
cacheAgeMs: null,
|
|
error:
|
|
error instanceof Error
|
|
? error.message
|
|
: 'Failed to query address',
|
|
})
|
|
}
|
|
}
|
|
|
|
return results
|
|
}
|
|
|
|
const server = http.createServer(async (req, res) => {
|
|
if (req.method === 'POST' && req.url === '/api/login') {
|
|
let body = ''
|
|
|
|
req.on('data', (chunk) => {
|
|
body += chunk
|
|
})
|
|
|
|
req.on('end', () => {
|
|
try {
|
|
const input = JSON.parse(body)
|
|
|
|
if (!checkPassword(input.password)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Invalid password',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
const token = createSession()
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
'Set-Cookie':
|
|
'munin_session=' +
|
|
encodeURIComponent(token) +
|
|
'; HttpOnly; Secure; SameSite=Strict; Path=/; Max-Age=86400',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
ok: true,
|
|
}),
|
|
)
|
|
} catch {
|
|
res.writeHead(400, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Invalid request',
|
|
}),
|
|
)
|
|
}
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
if (req.url === '/api/status') {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
try {
|
|
const status = await getStatus()
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(JSON.stringify(status))
|
|
} catch (error) {
|
|
console.error(
|
|
'Failed to get service status:',
|
|
error,
|
|
)
|
|
|
|
res.writeHead(500, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
service: 'running',
|
|
error: 'Failed to determine service status',
|
|
}),
|
|
)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if (req.method === 'GET' && req.url === '/api/addresses') {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
try {
|
|
const addresses = await listAddresses()
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
addresses,
|
|
}),
|
|
)
|
|
} catch (error) {
|
|
console.error(
|
|
'Failed to list addresses:',
|
|
error,
|
|
)
|
|
|
|
res.writeHead(500, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Failed to list addresses',
|
|
}),
|
|
)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if (
|
|
req.method === 'GET' &&
|
|
req.url === '/api/addresses/data'
|
|
) {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
try {
|
|
const addresses = await getAddressesWithData()
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
addresses,
|
|
}),
|
|
)
|
|
} catch (error) {
|
|
console.error(
|
|
'Failed to get address data:',
|
|
error,
|
|
)
|
|
|
|
res.writeHead(500, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Failed to get address data',
|
|
}),
|
|
)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if (
|
|
req.method === 'POST' &&
|
|
req.url === '/api/addresses'
|
|
) {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
let body = ''
|
|
|
|
req.on('data', (chunk) => {
|
|
body += chunk
|
|
})
|
|
|
|
req.on('end', async () => {
|
|
try {
|
|
const input = JSON.parse(body)
|
|
|
|
const entry = await addAddress(
|
|
input.address,
|
|
input.label,
|
|
)
|
|
|
|
res.writeHead(201, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(JSON.stringify(entry))
|
|
} catch (error) {
|
|
res.writeHead(400, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error:
|
|
error instanceof Error
|
|
? error.message
|
|
: 'Failed to add address',
|
|
}),
|
|
)
|
|
}
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
if (
|
|
req.method === 'DELETE' &&
|
|
req.url === '/api/addresses'
|
|
) {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
let body = ''
|
|
|
|
req.on('data', (chunk) => {
|
|
body += chunk
|
|
})
|
|
|
|
req.on('end', async () => {
|
|
try {
|
|
const input = JSON.parse(body)
|
|
|
|
await removeAddress(input.address)
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
ok: true,
|
|
}),
|
|
)
|
|
} catch (error) {
|
|
res.writeHead(400, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error:
|
|
error instanceof Error
|
|
? error.message
|
|
: 'Failed to remove address',
|
|
}),
|
|
)
|
|
}
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
if (
|
|
req.method === 'GET' &&
|
|
req.url.startsWith('/api/transactions/')
|
|
) {
|
|
if (!isValidSession(req)) {
|
|
res.writeHead(401, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error: 'Authentication required',
|
|
}),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
const txid = decodeURIComponent(
|
|
req.url.slice('/api/transactions/'.length),
|
|
)
|
|
|
|
try {
|
|
const transaction = await getTransaction(txid)
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(JSON.stringify(transaction))
|
|
} catch (error) {
|
|
res.writeHead(400, {
|
|
'Content-Type': 'application/json',
|
|
})
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
error:
|
|
error instanceof Error
|
|
? error.message
|
|
: 'Failed to get transaction',
|
|
}),
|
|
)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
res.writeHead(404)
|
|
res.end('Not found')
|
|
})
|
|
|
|
server.listen(port, () => {
|
|
console.log(
|
|
`Status API listening on port ${port}`,
|
|
)
|
|
}) |