134 lines
4.2 KiB
JavaScript
134 lines
4.2 KiB
JavaScript
const t = require('assert')
|
|
const bscript = require('../src/script')
|
|
const BNETWORKS = require('../src/networks')
|
|
|
|
function tryHex (x) {
|
|
if (Buffer.isBuffer(x)) return x.toString('hex')
|
|
if (Array.isArray(x)) return x.map(tryHex)
|
|
return x
|
|
}
|
|
|
|
function fromHex (x) {
|
|
if (typeof x === 'string') return Buffer.from(x, 'hex')
|
|
if (Array.isArray(x)) return x.map(fromHex)
|
|
return x
|
|
}
|
|
function tryASM (x) {
|
|
if (Buffer.isBuffer(x)) return bscript.toASM(x)
|
|
return x
|
|
}
|
|
function asmToBuffer (x) {
|
|
if (x === '') return Buffer.alloc(0)
|
|
return bscript.fromASM(x)
|
|
}
|
|
function carryOver (a, b) {
|
|
for (let k in b) {
|
|
if (k in a && k === 'redeem') {
|
|
carryOver(a[k], b[k])
|
|
continue
|
|
}
|
|
|
|
// don't, the value was specified
|
|
if (k in a) continue
|
|
|
|
// otherwise, expect match
|
|
a[k] = b[k]
|
|
}
|
|
}
|
|
|
|
function equateBase (a, b, context) {
|
|
if ('output' in b) t.strictEqual(tryASM(a.output), tryASM(b.output), `Inequal ${context}output`)
|
|
if ('input' in b) t.strictEqual(tryASM(a.input), tryASM(b.input), `Inequal ${context}input`)
|
|
if ('witness' in b) t.deepEqual(tryHex(a.witness), tryHex(b.witness), `Inequal ${context}witness`)
|
|
}
|
|
|
|
function equate (a, b, args) {
|
|
b = Object.assign({}, b)
|
|
carryOver(b, args)
|
|
|
|
// by null, we mean 'undefined', but JSON
|
|
if (b.input === null) b.input = undefined
|
|
if (b.output === null) b.output = undefined
|
|
if (b.witness === null) b.witness = undefined
|
|
if (b.redeem) {
|
|
if (b.redeem.input === null) b.redeem.input = undefined
|
|
if (b.redeem.output === null) b.redeem.output = undefined
|
|
if (b.redeem.witness === null) b.redeem.witness = undefined
|
|
}
|
|
|
|
equateBase(a, b, '')
|
|
if (b.redeem) equateBase(a.redeem, b.redeem, 'redeem.')
|
|
if (b.network) t.deepEqual(a.network, BNETWORKS[b.network], 'Inequal *.network')
|
|
|
|
// contextual
|
|
if (b.signature === null) b.signature = undefined
|
|
if ('address' in b) t.strictEqual(a.address, b.address, 'Inequal *.address')
|
|
if ('hash' in b) t.strictEqual(tryHex(a.hash), tryHex(b.hash), 'Inequal *.hash')
|
|
if ('pubkey' in b) t.strictEqual(tryHex(a.pubkey), tryHex(b.pubkey), 'Inequal *.pubkey')
|
|
if ('signature' in b) t.strictEqual(tryHex(a.signature), tryHex(b.signature), 'Inequal signature')
|
|
if ('m' in b) t.strictEqual(a.m, b.m, 'Inequal *.m')
|
|
if ('n' in b) t.strictEqual(a.n, b.n, 'Inequal *.n')
|
|
if ('pubkeys' in b) t.deepEqual(tryHex(a.pubkeys), tryHex(b.pubkeys), 'Inequal *.pubkeys')
|
|
if ('signatures' in b) t.deepEqual(tryHex(a.signatures), tryHex(b.signatures), 'Inequal *.signatures')
|
|
if ('data' in b) t.deepEqual(tryHex(a.data), tryHex(b.data), 'Inequal *.data')
|
|
}
|
|
|
|
function preform (x) {
|
|
x = Object.assign({}, x)
|
|
|
|
if (x.network) x.network = BNETWORKS[x.network]
|
|
if (typeof x.inputHex === 'string') {
|
|
x.input = Buffer.from(x.inputHex, 'hex')
|
|
delete x.inputHex
|
|
}
|
|
if (typeof x.outputHex === 'string') {
|
|
x.output = Buffer.from(x.outputHex, 'hex')
|
|
delete x.outputHex
|
|
}
|
|
if (typeof x.output === 'string') x.output = asmToBuffer(x.output)
|
|
if (typeof x.input === 'string') x.input = asmToBuffer(x.input)
|
|
if (Array.isArray(x.witness)) x.witness = x.witness.map(fromHex)
|
|
|
|
if (x.data) x.data = x.data.map(fromHex)
|
|
if (x.hash) x.hash = Buffer.from(x.hash, 'hex')
|
|
if (x.pubkey) x.pubkey = Buffer.from(x.pubkey, 'hex')
|
|
if (x.signature) x.signature = Buffer.from(x.signature, 'hex')
|
|
if (x.pubkeys) x.pubkeys = x.pubkeys.map(fromHex)
|
|
if (x.signatures) x.signatures = x.signatures.map(function (y) { return Number.isFinite(y) ? y : Buffer.from(y, 'hex') })
|
|
if (x.redeem) {
|
|
x.redeem = Object.assign({}, x.redeem)
|
|
if (typeof x.redeem.input === 'string') x.redeem.input = asmToBuffer(x.redeem.input)
|
|
if (typeof x.redeem.output === 'string') x.redeem.output = asmToBuffer(x.redeem.output)
|
|
if (Array.isArray(x.redeem.witness)) x.redeem.witness = x.redeem.witness.map(fromHex)
|
|
if (x.redeem.network) x.redeem.network = BNETWORKS[x.redeem.network]
|
|
}
|
|
|
|
return x
|
|
}
|
|
|
|
function from (path, object, result) {
|
|
path = path.split('.')
|
|
result = result || {}
|
|
|
|
let r = result
|
|
path.forEach((k, i) => {
|
|
if (i < path.length - 1) {
|
|
r[k] = r[k] || {}
|
|
|
|
// recurse
|
|
r = r[k]
|
|
object = object[k]
|
|
} else {
|
|
r[k] = object[k]
|
|
}
|
|
})
|
|
|
|
return result
|
|
}
|
|
|
|
module.exports = {
|
|
from,
|
|
equate,
|
|
preform
|
|
}
|