129 lines
2.8 KiB
JavaScript
129 lines
2.8 KiB
JavaScript
'use strict'
|
|
|
|
var bufferutils = require('./bufferutils')
|
|
var typeforce = require('typeforce')
|
|
var types = require('./types')
|
|
var zconst = require('./const')
|
|
|
|
var JSInput = require('./jsinput')
|
|
var Note = require('./note')
|
|
|
|
function JSProofWitness (phi, rt, hSig, inputs, notes, vpubOld, vpubNew) {
|
|
typeforce(types.tuple(
|
|
types.Buffer252bit,
|
|
types.Buffer256bit,
|
|
types.Buffer256bit,
|
|
[types.JSInput],
|
|
[types.Note],
|
|
types.Zatoshi,
|
|
types.Zatoshi
|
|
), arguments)
|
|
|
|
this.phi = phi
|
|
this.rt = rt
|
|
this.hSig = hSig
|
|
this.inputs = inputs
|
|
this.notes = notes
|
|
this.vpub_old = vpubOld
|
|
this.vpub_new = vpubNew
|
|
}
|
|
|
|
JSProofWitness.fromBuffer = function (buffer, __noStrict) {
|
|
var offset = 0
|
|
function readSlice (n) {
|
|
offset += n
|
|
return buffer.slice(offset - n, offset)
|
|
}
|
|
|
|
function readUInt64 () {
|
|
var i = bufferutils.readUInt64LE(buffer, offset)
|
|
offset += 8
|
|
return i
|
|
}
|
|
|
|
function readJSInput () {
|
|
var input = JSInput.fromBuffer(buffer.slice(offset), true)
|
|
offset += input.byteLength()
|
|
return input
|
|
}
|
|
|
|
function readNote () {
|
|
var proof = Note.fromBuffer(buffer.slice(offset), true)
|
|
offset += proof.byteLength()
|
|
return proof
|
|
}
|
|
|
|
var phi = readSlice(32)
|
|
var rt = readSlice(32)
|
|
var hSig = readSlice(32)
|
|
|
|
var inputs = []
|
|
for (var i = 0; i < zconst.ZC_NUM_JS_INPUTS; ++i) {
|
|
inputs.push(readJSInput())
|
|
}
|
|
|
|
var notes = []
|
|
for (i = 0; i < zconst.ZC_NUM_JS_OUTPUTS; ++i) {
|
|
notes.push(readNote())
|
|
}
|
|
|
|
var vpubOld = readUInt64()
|
|
var vpubNew = readUInt64()
|
|
var witness = new JSProofWitness(phi, rt, hSig, inputs, notes, vpubOld, vpubNew)
|
|
|
|
if (__noStrict) return witness
|
|
if (offset !== buffer.length) throw new Error('JSProofWitness has unexpected data')
|
|
|
|
return witness
|
|
}
|
|
|
|
JSProofWitness.fromHex = function (hex) {
|
|
return JSProofWitness.fromBuffer(Buffer.from(hex, 'hex'))
|
|
}
|
|
|
|
JSProofWitness.prototype.byteLength = function () {
|
|
return (
|
|
112 +
|
|
this.inputs.reduce(function (sum, input) { return sum + input.byteLength() }, 0) +
|
|
this.notes.reduce(function (sum, note) { return sum + note.byteLength() }, 0)
|
|
)
|
|
}
|
|
|
|
JSProofWitness.prototype.toBuffer = function () {
|
|
var buffer = Buffer.alloc(this.byteLength())
|
|
|
|
var offset = 0
|
|
function writeSlice (slice) {
|
|
slice.copy(buffer, offset)
|
|
offset += slice.length
|
|
}
|
|
|
|
function writeUInt64 (i) {
|
|
bufferutils.writeUInt64LE(buffer, i, offset)
|
|
offset += 8
|
|
}
|
|
|
|
writeSlice(this.phi)
|
|
writeSlice(this.rt)
|
|
writeSlice(this.hSig)
|
|
|
|
this.inputs.forEach(function (input) {
|
|
writeSlice(input.toBuffer())
|
|
})
|
|
|
|
this.notes.forEach(function (note) {
|
|
writeSlice(note.toBuffer())
|
|
})
|
|
|
|
writeUInt64(this.vpub_old)
|
|
writeUInt64(this.vpub_new)
|
|
|
|
return buffer
|
|
}
|
|
|
|
JSProofWitness.prototype.toHex = function () {
|
|
return this.toBuffer().toString('hex')
|
|
}
|
|
|
|
module.exports = JSProofWitness
|