Browse Source

Refactor: Re-order helper functions based on like-kind

psbt
junderw 6 years ago
parent
commit
479c56bbb4
No known key found for this signature in database GPG Key ID: B256185D3A971908
  1. 560
      src/psbt.js
  2. 677
      ts_src/psbt.ts

560
src/psbt.js

@ -352,30 +352,119 @@ class Psbt extends bip174_1.Psbt {
} }
} }
exports.Psbt = Psbt; exports.Psbt = Psbt;
function addNonWitnessTxCache(cache, input, inputIndex) { function canFinalize(input, script, scriptType) {
cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo; switch (scriptType) {
const tx = transaction_1.Transaction.fromBuffer(input.nonWitnessUtxo); case 'pubkey':
cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx; case 'pubkeyhash':
const self = cache; case 'witnesspubkeyhash':
const selfIndex = inputIndex; return hasSigs(1, input.partialSig);
delete input.nonWitnessUtxo; case 'multisig':
Object.defineProperty(input, 'nonWitnessUtxo', { const p2ms = payments.p2ms({ output: script });
enumerable: true, return hasSigs(p2ms.m, input.partialSig);
get() { default:
const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex]; return false;
const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];
if (buf !== undefined) {
return buf;
} else {
const newBuf = txCache.toBuffer();
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf;
return newBuf;
} }
}, }
set(data) { function hasSigs(neededSigs, partialSig) {
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data; if (!partialSig) return false;
}, if (partialSig.length > neededSigs) throw new Error('Too many signatures');
return partialSig.length === neededSigs;
}
function isFinalized(input) {
return !!input.finalScriptSig || !!input.finalScriptWitness;
}
function isPaymentFactory(payment) {
return script => {
try {
payment({ output: script });
return true;
} catch (err) {
return false;
}
};
}
const isP2MS = isPaymentFactory(payments.p2ms);
const isP2PK = isPaymentFactory(payments.p2pk);
const isP2PKH = isPaymentFactory(payments.p2pkh);
const isP2WPKH = isPaymentFactory(payments.p2wpkh);
function check32Bit(num) {
if (
typeof num !== 'number' ||
num !== Math.floor(num) ||
num > 0xffffffff ||
num < 0
) {
throw new Error('Invalid 32 bit integer');
}
}
function checkFees(psbt, cache, opts) {
const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
const vsize = cache.__EXTRACTED_TX.virtualSize();
const satoshis = feeRate * vsize;
if (feeRate >= opts.maximumFeeRate) {
throw new Error(
`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
`fees, which is ${feeRate} satoshi per byte for a transaction ` +
`with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
`byte). Use setMaximumFeeRate method to raise your threshold, or ` +
`pass true to the first arg of extractTransaction.`,
);
}
}
function checkInputsForPartialSig(inputs, action) {
inputs.forEach(input => {
let throws = false;
if ((input.partialSig || []).length === 0) return;
input.partialSig.forEach(pSig => {
const { hashType } = bscript.signature.decode(pSig.signature);
const whitelist = [];
const isAnyoneCanPay =
hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY;
if (isAnyoneCanPay) whitelist.push('addInput');
const hashMod = hashType & 0x1f;
switch (hashMod) {
case transaction_1.Transaction.SIGHASH_ALL:
break;
case transaction_1.Transaction.SIGHASH_SINGLE:
case transaction_1.Transaction.SIGHASH_NONE:
whitelist.push('addOutput');
whitelist.push('setSequence');
break;
}
if (whitelist.indexOf(action) === -1) {
throws = true;
}
});
if (throws) {
throw new Error('Can not modify transaction, signatures exist.');
}
});
}
function checkScriptForPubkey(pubkey, script, action) {
const pubkeyHash = crypto_1.hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
const hasKey = decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
}); });
if (!hasKey) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
}
}
function checkTxEmpty(tx) {
const isEmpty = tx.ins.every(
input =>
input.script &&
input.script.length === 0 &&
input.witness &&
input.witness.length === 0,
);
if (!isEmpty) {
throw new Error('Format Error: Transaction ScriptSigs are not empty');
}
} }
function checkTxForDupeIns(tx, cache) { function checkTxForDupeIns(tx, cache) {
tx.ins.forEach(input => { tx.ins.forEach(input => {
@ -390,18 +479,23 @@ function checkTxInputCache(cache, input) {
if (cache.__TX_IN_CACHE[key]) throw new Error('Duplicate input detected.'); if (cache.__TX_IN_CACHE[key]) throw new Error('Duplicate input detected.');
cache.__TX_IN_CACHE[key] = 1; cache.__TX_IN_CACHE[key] = 1;
} }
function isFinalized(input) { function scriptCheckerFactory(payment, paymentScriptName) {
return !!input.finalScriptSig || !!input.finalScriptWitness; return (inputIndex, scriptPubKey, redeemScript) => {
} const redeemScriptOutput = payment({
function getHashAndSighashType(inputs, inputIndex, pubkey, cache) { redeem: { output: redeemScript },
const input = utils_1.checkForInput(inputs, inputIndex); }).output;
const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache); if (!scriptPubKey.equals(redeemScriptOutput)) {
checkScriptForPubkey(pubkey, script, 'sign'); throw new Error(
return { `${paymentScriptName} for input #${inputIndex} doesn't match the scriptPubKey in the prevout`,
hash, );
sighashType, }
}; };
} }
const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
const checkWitnessScript = scriptCheckerFactory(
payments.p2wsh,
'Witness script',
);
function getFinalScripts( function getFinalScripts(
script, script,
scriptType, scriptType,
@ -437,81 +531,14 @@ function getFinalScripts(
finalScriptWitness, finalScriptWitness,
}; };
} }
function getSortedSigs(script, partialSig) { function getHashAndSighashType(inputs, inputIndex, pubkey, cache) {
const p2ms = payments.p2ms({ output: script }); const input = utils_1.checkForInput(inputs, inputIndex);
// for each pubkey in order of p2ms script const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache);
return p2ms.pubkeys checkScriptForPubkey(pubkey, script, 'sign');
.map(pk => { return {
// filter partialSig array by pubkey being equal hash,
return ( sighashType,
partialSig.filter(ps => { };
return ps.pubkey.equals(pk);
})[0] || {}
).signature;
// Any pubkey without a match will return undefined
// this last filter removes all the undefined items in the array.
})
.filter(v => !!v);
}
function getPayment(script, scriptType, partialSig) {
let payment;
switch (scriptType) {
case 'multisig':
const sigs = getSortedSigs(script, partialSig);
payment = payments.p2ms({
output: script,
signatures: sigs,
});
break;
case 'pubkey':
payment = payments.p2pk({
output: script,
signature: partialSig[0].signature,
});
break;
case 'pubkeyhash':
payment = payments.p2pkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
case 'witnesspubkeyhash':
payment = payments.p2wpkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
}
return payment;
}
function canFinalize(input, script, scriptType) {
switch (scriptType) {
case 'pubkey':
case 'pubkeyhash':
case 'witnesspubkeyhash':
return hasSigs(1, input.partialSig);
case 'multisig':
const p2ms = payments.p2ms({ output: script });
return hasSigs(p2ms.m, input.partialSig);
default:
return false;
}
}
function checkScriptForPubkey(pubkey, script, action) {
const pubkeyHash = crypto_1.hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
const hasKey = decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
});
if (!hasKey) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
}
} }
function getHashForSig(inputIndex, input, cache) { function getHashForSig(inputIndex, input, cache) {
const unsignedTx = cache.__TX; const unsignedTx = cache.__TX;
@ -597,43 +624,87 @@ function getHashForSig(inputIndex, input, cache) {
hash, hash,
}; };
} }
function scriptCheckerFactory(payment, paymentScriptName) { function getInputAdder(cache) {
return (inputIndex, scriptPubKey, redeemScript) => { const selfCache = cache;
const redeemScriptOutput = payment({ return (_inputData, txBuf) => {
redeem: { output: redeemScript }, if (
}).output; !txBuf ||
if (!scriptPubKey.equals(redeemScriptOutput)) { _inputData.hash === undefined ||
throw new Error( _inputData.index === undefined ||
`${paymentScriptName} for input #${inputIndex} doesn't match the scriptPubKey in the prevout`, (!Buffer.isBuffer(_inputData.hash) &&
); typeof _inputData.hash !== 'string') ||
} typeof _inputData.index !== 'number'
}; ) {
} throw new Error('Error adding input.');
const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
const checkWitnessScript = scriptCheckerFactory(
payments.p2wsh,
'Witness script',
);
function isPaymentFactory(payment) {
return script => {
try {
payment({ output: script });
return true;
} catch (err) {
return false;
} }
const prevHash = Buffer.isBuffer(_inputData.hash)
? _inputData.hash
: bufferutils_1.reverseBuffer(Buffer.from(_inputData.hash, 'hex'));
// Check if input already exists in cache.
const input = { hash: prevHash, index: _inputData.index };
checkTxInputCache(selfCache, input);
selfCache.__TX.ins.push(
Object.assign({}, input, {
script: Buffer.alloc(0),
sequence:
_inputData.sequence || transaction_1.Transaction.DEFAULT_SEQUENCE,
witness: [],
}),
);
return selfCache.__TX.toBuffer();
}; };
} }
const isP2WPKH = isPaymentFactory(payments.p2wpkh); function getOutputAdder(cache) {
const isP2PKH = isPaymentFactory(payments.p2pkh); const selfCache = cache;
const isP2MS = isPaymentFactory(payments.p2ms); return (_outputData, txBuf) => {
const isP2PK = isPaymentFactory(payments.p2pk); if (
function classifyScript(script) { !txBuf ||
if (isP2WPKH(script)) return 'witnesspubkeyhash'; _outputData.script === undefined ||
if (isP2PKH(script)) return 'pubkeyhash'; _outputData.value === undefined ||
if (isP2MS(script)) return 'multisig'; !Buffer.isBuffer(_outputData.script) ||
if (isP2PK(script)) return 'pubkey'; typeof _outputData.value !== 'number'
return 'nonstandard'; ) {
throw new Error('Error adding output.');
}
selfCache.__TX.outs.push({
script: _outputData.script,
value: _outputData.value,
});
return selfCache.__TX.toBuffer();
};
}
function getPayment(script, scriptType, partialSig) {
let payment;
switch (scriptType) {
case 'multisig':
const sigs = getSortedSigs(script, partialSig);
payment = payments.p2ms({
output: script,
signatures: sigs,
});
break;
case 'pubkey':
payment = payments.p2pk({
output: script,
signature: partialSig[0].signature,
});
break;
case 'pubkeyhash':
payment = payments.p2pkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
case 'witnesspubkeyhash':
payment = payments.p2wpkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
}
return payment;
} }
function getScriptFromInput(inputIndex, input, cache) { function getScriptFromInput(inputIndex, input, cache) {
const unsignedTx = cache.__TX; const unsignedTx = cache.__TX;
@ -674,32 +745,21 @@ function getScriptFromInput(inputIndex, input, cache) {
} }
return res; return res;
} }
function hasSigs(neededSigs, partialSig) { function getSortedSigs(script, partialSig) {
if (!partialSig) return false; const p2ms = payments.p2ms({ output: script });
if (partialSig.length > neededSigs) throw new Error('Too many signatures'); // for each pubkey in order of p2ms script
return partialSig.length === neededSigs; return p2ms.pubkeys
} .map(pk => {
function witnessStackToScriptWitness(witness) { // filter partialSig array by pubkey being equal
let buffer = Buffer.allocUnsafe(0); return (
function writeSlice(slice) { partialSig.filter(ps => {
buffer = Buffer.concat([buffer, Buffer.from(slice)]); return ps.pubkey.equals(pk);
} })[0] || {}
function writeVarInt(i) { ).signature;
const currentLen = buffer.length; // Any pubkey without a match will return undefined
const varintLen = varuint.encodingLength(i); // this last filter removes all the undefined items in the array.
buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]); })
varuint.encode(i, buffer, currentLen); .filter(v => !!v);
}
function writeVarSlice(slice) {
writeVarInt(slice.length);
writeSlice(slice);
}
function writeVector(vector) {
writeVarInt(vector.length);
vector.forEach(writeVarSlice);
}
writeVector(witness);
return buffer;
} }
function scriptWitnessToWitnessStack(buffer) { function scriptWitnessToWitnessStack(buffer) {
let offset = 0; let offset = 0;
@ -723,118 +783,52 @@ function scriptWitnessToWitnessStack(buffer) {
} }
return readVector(); return readVector();
} }
function range(n) { function witnessStackToScriptWitness(witness) {
return [...Array(n).keys()]; let buffer = Buffer.allocUnsafe(0);
} function writeSlice(slice) {
function checkTxEmpty(tx) { buffer = Buffer.concat([buffer, Buffer.from(slice)]);
const isEmpty = tx.ins.every(
input =>
input.script &&
input.script.length === 0 &&
input.witness &&
input.witness.length === 0,
);
if (!isEmpty) {
throw new Error('Format Error: Transaction ScriptSigs are not empty');
}
}
function checkInputsForPartialSig(inputs, action) {
inputs.forEach(input => {
let throws = false;
if ((input.partialSig || []).length === 0) return;
input.partialSig.forEach(pSig => {
const { hashType } = bscript.signature.decode(pSig.signature);
const whitelist = [];
const isAnyoneCanPay =
hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY;
if (isAnyoneCanPay) whitelist.push('addInput');
const hashMod = hashType & 0x1f;
switch (hashMod) {
case transaction_1.Transaction.SIGHASH_ALL:
break;
case transaction_1.Transaction.SIGHASH_SINGLE:
case transaction_1.Transaction.SIGHASH_NONE:
whitelist.push('addOutput');
whitelist.push('setSequence');
break;
}
if (whitelist.indexOf(action) === -1) {
throws = true;
} }
}); function writeVarInt(i) {
if (throws) { const currentLen = buffer.length;
throw new Error('Can not modify transaction, signatures exist.'); const varintLen = varuint.encodingLength(i);
buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
varuint.encode(i, buffer, currentLen);
} }
}); function writeVarSlice(slice) {
} writeVarInt(slice.length);
function nonWitnessUtxoTxFromCache(cache, input, inputIndex) { writeSlice(slice);
if (!cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex]) {
addNonWitnessTxCache(cache, input, inputIndex);
} }
return cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex]; function writeVector(vector) {
} writeVarInt(vector.length);
function getInputAdder(cache) { vector.forEach(writeVarSlice);
const selfCache = cache;
return (_inputData, txBuf) => {
if (
!txBuf ||
_inputData.hash === undefined ||
_inputData.index === undefined ||
(!Buffer.isBuffer(_inputData.hash) &&
typeof _inputData.hash !== 'string') ||
typeof _inputData.index !== 'number'
) {
throw new Error('Error adding input.');
} }
const prevHash = Buffer.isBuffer(_inputData.hash) writeVector(witness);
? _inputData.hash return buffer;
: bufferutils_1.reverseBuffer(Buffer.from(_inputData.hash, 'hex'));
// Check if input already exists in cache.
const input = { hash: prevHash, index: _inputData.index };
checkTxInputCache(selfCache, input);
selfCache.__TX.ins.push(
Object.assign({}, input, {
script: Buffer.alloc(0),
sequence:
_inputData.sequence || transaction_1.Transaction.DEFAULT_SEQUENCE,
witness: [],
}),
);
return selfCache.__TX.toBuffer();
};
} }
function getOutputAdder(cache) { function addNonWitnessTxCache(cache, input, inputIndex) {
const selfCache = cache; cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo;
return (_outputData, txBuf) => { const tx = transaction_1.Transaction.fromBuffer(input.nonWitnessUtxo);
if ( cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx;
!txBuf || const self = cache;
_outputData.script === undefined || const selfIndex = inputIndex;
_outputData.value === undefined || delete input.nonWitnessUtxo;
!Buffer.isBuffer(_outputData.script) || Object.defineProperty(input, 'nonWitnessUtxo', {
typeof _outputData.value !== 'number' enumerable: true,
) { get() {
throw new Error('Error adding output.'); const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex];
const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];
if (buf !== undefined) {
return buf;
} else {
const newBuf = txCache.toBuffer();
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf;
return newBuf;
} }
selfCache.__TX.outs.push({ },
script: _outputData.script, set(data) {
value: _outputData.value, self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;
},
}); });
return selfCache.__TX.toBuffer();
};
}
function checkFees(psbt, cache, opts) {
const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
const vsize = cache.__EXTRACTED_TX.virtualSize();
const satoshis = feeRate * vsize;
if (feeRate >= opts.maximumFeeRate) {
throw new Error(
`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
`fees, which is ${feeRate} satoshi per byte for a transaction ` +
`with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
`byte). Use setMaximumFeeRate method to raise your threshold, or ` +
`pass true to the first arg of extractTransaction.`,
);
}
} }
function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, getAmounts) { function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, getAmounts) {
let inputAmount = 0; let inputAmount = 0;
@ -857,13 +851,19 @@ function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, getAmounts) {
}); });
return inputAmount; return inputAmount;
} }
function check32Bit(num) { function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
if ( if (!cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex]) {
typeof num !== 'number' || addNonWitnessTxCache(cache, input, inputIndex);
num !== Math.floor(num) ||
num > 0xffffffff ||
num < 0
) {
throw new Error('Invalid 32 bit integer');
} }
return cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex];
}
function classifyScript(script) {
if (isP2WPKH(script)) return 'witnesspubkeyhash';
if (isP2PKH(script)) return 'pubkeyhash';
if (isP2MS(script)) return 'multisig';
if (isP2PK(script)) return 'pubkey';
return 'nonstandard';
}
function range(n) {
return [...Array(n).keys()];
} }

677
ts_src/psbt.ts

@ -425,16 +425,6 @@ export class Psbt extends PsbtBase {
} }
} }
//
//
//
//
// Helper functions
//
//
//
//
interface PsbtCache { interface PsbtCache {
__NON_WITNESS_UTXO_TX_CACHE: Transaction[]; __NON_WITNESS_UTXO_TX_CACHE: Transaction[];
__NON_WITNESS_UTXO_BUF_CACHE: Buffer[]; __NON_WITNESS_UTXO_BUF_CACHE: Buffer[];
@ -455,38 +445,139 @@ interface PsbtOpts {
maximumFeeRate: number; maximumFeeRate: number;
} }
function addNonWitnessTxCache( function canFinalize(
cache: PsbtCache,
input: PsbtInput, input: PsbtInput,
inputIndex: number, script: Buffer,
): void { scriptType: string,
cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo!; ): boolean {
switch (scriptType) {
case 'pubkey':
case 'pubkeyhash':
case 'witnesspubkeyhash':
return hasSigs(1, input.partialSig);
case 'multisig':
const p2ms = payments.p2ms({ output: script });
return hasSigs(p2ms.m!, input.partialSig);
default:
return false;
}
}
const tx = Transaction.fromBuffer(input.nonWitnessUtxo!); function hasSigs(neededSigs: number, partialSig?: any[]): boolean {
cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx; if (!partialSig) return false;
if (partialSig.length > neededSigs) throw new Error('Too many signatures');
return partialSig.length === neededSigs;
}
const self = cache; function isFinalized(input: PsbtInput): boolean {
const selfIndex = inputIndex; return !!input.finalScriptSig || !!input.finalScriptWitness;
delete input.nonWitnessUtxo; }
Object.defineProperty(input, 'nonWitnessUtxo', {
enumerable: true, function isPaymentFactory(payment: any): (script: Buffer) => boolean {
get(): Buffer { return (script: Buffer): boolean => {
const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex]; try {
const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex]; payment({ output: script });
if (buf !== undefined) { return true;
return buf; } catch (err) {
} else { return false;
const newBuf = txCache.toBuffer(); }
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf; };
return newBuf; }
const isP2MS = isPaymentFactory(payments.p2ms);
const isP2PK = isPaymentFactory(payments.p2pk);
const isP2PKH = isPaymentFactory(payments.p2pkh);
const isP2WPKH = isPaymentFactory(payments.p2wpkh);
function check32Bit(num: number): void {
if (
typeof num !== 'number' ||
num !== Math.floor(num) ||
num > 0xffffffff ||
num < 0
) {
throw new Error('Invalid 32 bit integer');
}
}
function checkFees(psbt: Psbt, cache: PsbtCache, opts: PsbtOpts): void {
const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
const vsize = cache.__EXTRACTED_TX!.virtualSize();
const satoshis = feeRate * vsize;
if (feeRate >= opts.maximumFeeRate) {
throw new Error(
`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
`fees, which is ${feeRate} satoshi per byte for a transaction ` +
`with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
`byte). Use setMaximumFeeRate method to raise your threshold, or ` +
`pass true to the first arg of extractTransaction.`,
);
}
}
function checkInputsForPartialSig(inputs: PsbtInput[], action: string): void {
inputs.forEach(input => {
let throws = false;
if ((input.partialSig || []).length === 0) return;
input.partialSig!.forEach(pSig => {
const { hashType } = bscript.signature.decode(pSig.signature);
const whitelist: string[] = [];
const isAnyoneCanPay = hashType & Transaction.SIGHASH_ANYONECANPAY;
if (isAnyoneCanPay) whitelist.push('addInput');
const hashMod = hashType & 0x1f;
switch (hashMod) {
case Transaction.SIGHASH_ALL:
break;
case Transaction.SIGHASH_SINGLE:
case Transaction.SIGHASH_NONE:
whitelist.push('addOutput');
whitelist.push('setSequence');
break;
}
if (whitelist.indexOf(action) === -1) {
throws = true;
}
});
if (throws) {
throw new Error('Can not modify transaction, signatures exist.');
} }
},
set(data: Buffer): void {
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;
},
}); });
} }
function checkScriptForPubkey(
pubkey: Buffer,
script: Buffer,
action: string,
): void {
const pubkeyHash = hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
const hasKey = decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
});
if (!hasKey) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
}
}
function checkTxEmpty(tx: Transaction): void {
const isEmpty = tx.ins.every(
input =>
input.script &&
input.script.length === 0 &&
input.witness &&
input.witness.length === 0,
);
if (!isEmpty) {
throw new Error('Format Error: Transaction ScriptSigs are not empty');
}
}
function checkTxForDupeIns(tx: Transaction, cache: PsbtCache): void { function checkTxForDupeIns(tx: Transaction, cache: PsbtCache): void {
tx.ins.forEach(input => { tx.ins.forEach(input => {
checkTxInputCache(cache, input); checkTxInputCache(cache, input);
@ -503,27 +594,31 @@ function checkTxInputCache(
cache.__TX_IN_CACHE[key] = 1; cache.__TX_IN_CACHE[key] = 1;
} }
function isFinalized(input: PsbtInput): boolean { function scriptCheckerFactory(
return !!input.finalScriptSig || !!input.finalScriptWitness; payment: any,
} paymentScriptName: string,
): (idx: number, spk: Buffer, rs: Buffer) => void {
function getHashAndSighashType( return (
inputs: PsbtInput[],
inputIndex: number, inputIndex: number,
pubkey: Buffer, scriptPubKey: Buffer,
cache: PsbtCache, redeemScript: Buffer,
): { ): void => {
hash: Buffer; const redeemScriptOutput = payment({
sighashType: number; redeem: { output: redeemScript },
} { }).output as Buffer;
const input = checkForInput(inputs, inputIndex);
const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache); if (!scriptPubKey.equals(redeemScriptOutput)) {
checkScriptForPubkey(pubkey, script, 'sign'); throw new Error(
return { `${paymentScriptName} for input #${inputIndex} doesn't match the scriptPubKey in the prevout`,
hash, );
sighashType, }
}; };
} }
const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
const checkWitnessScript = scriptCheckerFactory(
payments.p2wsh,
'Witness script',
);
function getFinalScripts( function getFinalScripts(
script: Buffer, script: Buffer,
@ -566,112 +661,33 @@ function getFinalScripts(
}; };
} }
function getSortedSigs(script: Buffer, partialSig: PartialSig[]): Buffer[] { function getHashAndSighashType(
const p2ms = payments.p2ms({ output: script }); inputs: PsbtInput[],
// for each pubkey in order of p2ms script inputIndex: number,
return p2ms
.pubkeys!.map(pk => {
// filter partialSig array by pubkey being equal
return (
partialSig.filter(ps => {
return ps.pubkey.equals(pk);
})[0] || {}
).signature;
// Any pubkey without a match will return undefined
// this last filter removes all the undefined items in the array.
})
.filter(v => !!v);
}
function getPayment(
script: Buffer,
scriptType: string,
partialSig: PartialSig[],
): payments.Payment {
let payment: payments.Payment;
switch (scriptType) {
case 'multisig':
const sigs = getSortedSigs(script, partialSig);
payment = payments.p2ms({
output: script,
signatures: sigs,
});
break;
case 'pubkey':
payment = payments.p2pk({
output: script,
signature: partialSig[0].signature,
});
break;
case 'pubkeyhash':
payment = payments.p2pkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
case 'witnesspubkeyhash':
payment = payments.p2wpkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
}
return payment!;
}
function canFinalize(
input: PsbtInput,
script: Buffer,
scriptType: string,
): boolean {
switch (scriptType) {
case 'pubkey':
case 'pubkeyhash':
case 'witnesspubkeyhash':
return hasSigs(1, input.partialSig);
case 'multisig':
const p2ms = payments.p2ms({ output: script });
return hasSigs(p2ms.m!, input.partialSig);
default:
return false;
}
}
function checkScriptForPubkey(
pubkey: Buffer, pubkey: Buffer,
script: Buffer, cache: PsbtCache,
action: string, ): {
): void {
const pubkeyHash = hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
const hasKey = decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
});
if (!hasKey) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
}
}
interface HashForSigData {
script: Buffer;
hash: Buffer; hash: Buffer;
sighashType: number; sighashType: number;
} {
const input = checkForInput(inputs, inputIndex);
const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache);
checkScriptForPubkey(pubkey, script, 'sign');
return {
hash,
sighashType,
};
} }
function getHashForSig( function getHashForSig(
inputIndex: number, inputIndex: number,
input: PsbtInput, input: PsbtInput,
cache: PsbtCache, cache: PsbtCache,
): HashForSigData { ): {
script: Buffer;
hash: Buffer;
sighashType: number;
} {
const unsignedTx = cache.__TX; const unsignedTx = cache.__TX;
const sighashType = input.sighashType || Transaction.SIGHASH_ALL; const sighashType = input.sighashType || Transaction.SIGHASH_ALL;
let hash: Buffer; let hash: Buffer;
@ -760,58 +776,97 @@ function getHashForSig(
}; };
} }
type ScriptCheckerFunction = (idx: number, spk: Buffer, rs: Buffer) => void; function getInputAdder(
cache: PsbtCache,
): (_inputData: TransactionInput, txBuf: Buffer) => Buffer {
const selfCache = cache;
return (_inputData: TransactionInput, txBuf: Buffer): Buffer => {
if (
!txBuf ||
(_inputData as any).hash === undefined ||
(_inputData as any).index === undefined ||
(!Buffer.isBuffer((_inputData as any).hash) &&
typeof (_inputData as any).hash !== 'string') ||
typeof (_inputData as any).index !== 'number'
) {
throw new Error('Error adding input.');
}
const prevHash = Buffer.isBuffer(_inputData.hash)
? _inputData.hash
: reverseBuffer(Buffer.from(_inputData.hash, 'hex'));
function scriptCheckerFactory( // Check if input already exists in cache.
payment: any, const input = { hash: prevHash, index: _inputData.index };
paymentScriptName: string, checkTxInputCache(selfCache, input);
): ScriptCheckerFunction {
return (
inputIndex: number,
scriptPubKey: Buffer,
redeemScript: Buffer,
): void => {
const redeemScriptOutput = payment({
redeem: { output: redeemScript },
}).output as Buffer;
if (!scriptPubKey.equals(redeemScriptOutput)) { selfCache.__TX.ins.push({
throw new Error( ...input,
`${paymentScriptName} for input #${inputIndex} doesn't match the scriptPubKey in the prevout`, script: Buffer.alloc(0),
); sequence: _inputData.sequence || Transaction.DEFAULT_SEQUENCE,
} witness: [],
});
return selfCache.__TX.toBuffer();
}; };
} }
const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script'); function getOutputAdder(
const checkWitnessScript = scriptCheckerFactory( cache: PsbtCache,
payments.p2wsh, ): (_outputData: TransactionOutput, txBuf: Buffer) => Buffer {
'Witness script', const selfCache = cache;
); return (_outputData: TransactionOutput, txBuf: Buffer): Buffer => {
if (
type isPaymentFunction = (script: Buffer) => boolean; !txBuf ||
(_outputData as any).script === undefined ||
(_outputData as any).value === undefined ||
!Buffer.isBuffer((_outputData as any).script) ||
typeof (_outputData as any).value !== 'number'
) {
throw new Error('Error adding output.');
}
selfCache.__TX.outs.push({
script: (_outputData as any).script!,
value: _outputData.value,
});
return selfCache.__TX.toBuffer();
};
}
function isPaymentFactory(payment: any): isPaymentFunction { function getPayment(
return (script: Buffer): boolean => { script: Buffer,
try { scriptType: string,
payment({ output: script }); partialSig: PartialSig[],
return true; ): payments.Payment {
} catch (err) { let payment: payments.Payment;
return false; switch (scriptType) {
case 'multisig':
const sigs = getSortedSigs(script, partialSig);
payment = payments.p2ms({
output: script,
signatures: sigs,
});
break;
case 'pubkey':
payment = payments.p2pk({
output: script,
signature: partialSig[0].signature,
});
break;
case 'pubkeyhash':
payment = payments.p2pkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
case 'witnesspubkeyhash':
payment = payments.p2wpkh({
output: script,
pubkey: partialSig[0].pubkey,
signature: partialSig[0].signature,
});
break;
} }
}; return payment!;
}
const isP2WPKH = isPaymentFactory(payments.p2wpkh);
const isP2PKH = isPaymentFactory(payments.p2pkh);
const isP2MS = isPaymentFactory(payments.p2ms);
const isP2PK = isPaymentFactory(payments.p2pk);
function classifyScript(script: Buffer): string {
if (isP2WPKH(script)) return 'witnesspubkeyhash';
if (isP2PKH(script)) return 'pubkeyhash';
if (isP2MS(script)) return 'multisig';
if (isP2PK(script)) return 'pubkey';
return 'nonstandard';
} }
interface GetScriptReturn { interface GetScriptReturn {
@ -864,40 +919,21 @@ function getScriptFromInput(
return res; return res;
} }
function hasSigs(neededSigs: number, partialSig?: any[]): boolean { function getSortedSigs(script: Buffer, partialSig: PartialSig[]): Buffer[] {
if (!partialSig) return false; const p2ms = payments.p2ms({ output: script });
if (partialSig.length > neededSigs) throw new Error('Too many signatures'); // for each pubkey in order of p2ms script
return partialSig.length === neededSigs; return p2ms
} .pubkeys!.map(pk => {
// filter partialSig array by pubkey being equal
function witnessStackToScriptWitness(witness: Buffer[]): Buffer { return (
let buffer = Buffer.allocUnsafe(0); partialSig.filter(ps => {
return ps.pubkey.equals(pk);
function writeSlice(slice: Buffer): void { })[0] || {}
buffer = Buffer.concat([buffer, Buffer.from(slice)]); ).signature;
} // Any pubkey without a match will return undefined
// this last filter removes all the undefined items in the array.
function writeVarInt(i: number): void { })
const currentLen = buffer.length; .filter(v => !!v);
const varintLen = varuint.encodingLength(i);
buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
varuint.encode(i, buffer, currentLen);
}
function writeVarSlice(slice: Buffer): void {
writeVarInt(slice.length);
writeSlice(slice);
}
function writeVector(vector: Buffer[]): void {
writeVarInt(vector.length);
vector.forEach(writeVarSlice);
}
writeVector(witness);
return buffer;
} }
function scriptWitnessToWitnessStack(buffer: Buffer): Buffer[] { function scriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
@ -928,131 +964,66 @@ function scriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
return readVector(); return readVector();
} }
function range(n: number): number[] { function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
return [...Array(n).keys()]; let buffer = Buffer.allocUnsafe(0);
}
function checkTxEmpty(tx: Transaction): void { function writeSlice(slice: Buffer): void {
const isEmpty = tx.ins.every( buffer = Buffer.concat([buffer, Buffer.from(slice)]);
input =>
input.script &&
input.script.length === 0 &&
input.witness &&
input.witness.length === 0,
);
if (!isEmpty) {
throw new Error('Format Error: Transaction ScriptSigs are not empty');
} }
}
function checkInputsForPartialSig(inputs: PsbtInput[], action: string): void { function writeVarInt(i: number): void {
inputs.forEach(input => { const currentLen = buffer.length;
let throws = false; const varintLen = varuint.encodingLength(i);
if ((input.partialSig || []).length === 0) return;
input.partialSig!.forEach(pSig => { buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
const { hashType } = bscript.signature.decode(pSig.signature); varuint.encode(i, buffer, currentLen);
const whitelist: string[] = [];
const isAnyoneCanPay = hashType & Transaction.SIGHASH_ANYONECANPAY;
if (isAnyoneCanPay) whitelist.push('addInput');
const hashMod = hashType & 0x1f;
switch (hashMod) {
case Transaction.SIGHASH_ALL:
break;
case Transaction.SIGHASH_SINGLE:
case Transaction.SIGHASH_NONE:
whitelist.push('addOutput');
whitelist.push('setSequence');
break;
}
if (whitelist.indexOf(action) === -1) {
throws = true;
}
});
if (throws) {
throw new Error('Can not modify transaction, signatures exist.');
} }
});
}
function nonWitnessUtxoTxFromCache( function writeVarSlice(slice: Buffer): void {
cache: PsbtCache, writeVarInt(slice.length);
input: PsbtInput, writeSlice(slice);
inputIndex: number,
): Transaction {
if (!cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex]) {
addNonWitnessTxCache(cache, input, inputIndex);
} }
return cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex];
}
function getInputAdder( function writeVector(vector: Buffer[]): void {
cache: PsbtCache, writeVarInt(vector.length);
): (_inputData: TransactionInput, txBuf: Buffer) => Buffer { vector.forEach(writeVarSlice);
const selfCache = cache;
return (_inputData: TransactionInput, txBuf: Buffer): Buffer => {
if (
!txBuf ||
(_inputData as any).hash === undefined ||
(_inputData as any).index === undefined ||
(!Buffer.isBuffer((_inputData as any).hash) &&
typeof (_inputData as any).hash !== 'string') ||
typeof (_inputData as any).index !== 'number'
) {
throw new Error('Error adding input.');
} }
const prevHash = Buffer.isBuffer(_inputData.hash)
? _inputData.hash
: reverseBuffer(Buffer.from(_inputData.hash, 'hex'));
// Check if input already exists in cache. writeVector(witness);
const input = { hash: prevHash, index: _inputData.index };
checkTxInputCache(selfCache, input);
selfCache.__TX.ins.push({ return buffer;
...input,
script: Buffer.alloc(0),
sequence: _inputData.sequence || Transaction.DEFAULT_SEQUENCE,
witness: [],
});
return selfCache.__TX.toBuffer();
};
} }
function getOutputAdder( function addNonWitnessTxCache(
cache: PsbtCache, cache: PsbtCache,
): (_outputData: TransactionOutput, txBuf: Buffer) => Buffer { input: PsbtInput,
const selfCache = cache; inputIndex: number,
return (_outputData: TransactionOutput, txBuf: Buffer): Buffer => { ): void {
if ( cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo!;
!txBuf ||
(_outputData as any).script === undefined ||
(_outputData as any).value === undefined ||
!Buffer.isBuffer((_outputData as any).script) ||
typeof (_outputData as any).value !== 'number'
) {
throw new Error('Error adding output.');
}
selfCache.__TX.outs.push({
script: (_outputData as any).script!,
value: _outputData.value,
});
return selfCache.__TX.toBuffer();
};
}
function checkFees(psbt: Psbt, cache: PsbtCache, opts: PsbtOpts): void { const tx = Transaction.fromBuffer(input.nonWitnessUtxo!);
const feeRate = cache.__FEE_RATE || psbt.getFeeRate(); cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx;
const vsize = cache.__EXTRACTED_TX!.virtualSize();
const satoshis = feeRate * vsize; const self = cache;
if (feeRate >= opts.maximumFeeRate) { const selfIndex = inputIndex;
throw new Error( delete input.nonWitnessUtxo;
`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` + Object.defineProperty(input, 'nonWitnessUtxo', {
`fees, which is ${feeRate} satoshi per byte for a transaction ` + enumerable: true,
`with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` + get(): Buffer {
`byte). Use setMaximumFeeRate method to raise your threshold, or ` + const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex];
`pass true to the first arg of extractTransaction.`, const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];
); if (buf !== undefined) {
return buf;
} else {
const newBuf = txCache.toBuffer();
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf;
return newBuf;
} }
},
set(data: Buffer): void {
self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;
},
});
} }
function inputFinalizeGetAmts( function inputFinalizeGetAmts(
@ -1083,13 +1054,25 @@ function inputFinalizeGetAmts(
return inputAmount; return inputAmount;
} }
function check32Bit(num: number): void { function nonWitnessUtxoTxFromCache(
if ( cache: PsbtCache,
typeof num !== 'number' || input: PsbtInput,
num !== Math.floor(num) || inputIndex: number,
num > 0xffffffff || ): Transaction {
num < 0 if (!cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex]) {
) { addNonWitnessTxCache(cache, input, inputIndex);
throw new Error('Invalid 32 bit integer');
} }
return cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex];
}
function classifyScript(script: Buffer): string {
if (isP2WPKH(script)) return 'witnesspubkeyhash';
if (isP2PKH(script)) return 'pubkeyhash';
if (isP2MS(script)) return 'multisig';
if (isP2PK(script)) return 'pubkey';
return 'nonstandard';
}
function range(n: number): number[] {
return [...Array(n).keys()];
} }

Loading…
Cancel
Save