LBRYCommunity/bitcoinjs-lib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add inputHasPubkey and outputHasPubkey methods

Browse source
This commit is contained in:
junderw 2020-04-27 17:10:11 +09:00
parent 4eb698df50
commit 361ea7c098
No known key found for this signature in database
GPG key ID: B256185D3A971908
4 changed files with 349 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
src/psbt.js
View file

@ -277,6 +277,14 @@ class Psbt {
this.data.clearFinalizedInput(inputIndex);
return this;
}
inputHasPubkey(inputIndex, pubkey) {
const input = utils_1.checkForInput(this.data.inputs, inputIndex);
return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
}
outputHasPubkey(outputIndex, pubkey) {
const output = utils_1.checkForOutput(this.data.outputs, outputIndex);
return pubkeyInOutput(pubkey, output, outputIndex, this.__CACHE);
}
validateSignaturesOfAllInputs() {
utils_1.checkForInput(this.data.inputs, 0); // making sure we have at least one
const results = range(this.data.inputs.length).map(idx =>
@ -653,6 +661,7 @@ const isP2PK = isPaymentFactory(payments.p2pk);
const isP2PKH = isPaymentFactory(payments.p2pkh);
const isP2WPKH = isPaymentFactory(payments.p2wpkh);
const isP2WSHScript = isPaymentFactory(payments.p2wsh);
const isP2SHScript = isPaymentFactory(payments.p2sh);
function check32Bit(num) {
if (
typeof num !== 'number' ||
@ -723,14 +732,7 @@ function checkPartialSigSighashes(input) {
});
}
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) {
if (!pubkeyInScript(pubkey, script)) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
@ -1219,6 +1221,88 @@ function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
}
return c[inputIndex];
}
function pubkeyInInput(pubkey, input, inputIndex, cache) {
let script;
if (input.witnessUtxo !== undefined) {
script = input.witnessUtxo.script;
} else if (input.nonWitnessUtxo !== undefined) {
const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
cache,
input,
inputIndex,
);
script = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
} else {
throw new Error("Can't find pubkey in input without Utxo data");
}
const meaningfulScript = checkScripts(
script,
input.redeemScript,
input.witnessScript,
);
return pubkeyInScript(pubkey, meaningfulScript);
}
function pubkeyInOutput(pubkey, output, outputIndex, cache) {
const script = cache.__TX.outs[outputIndex].script;
const meaningfulScript = checkScripts(
script,
output.redeemScript,
output.witnessScript,
);
return pubkeyInScript(pubkey, meaningfulScript);
}
function checkScripts(script, redeemScript, witnessScript) {
let fail = false;
if (isP2SHScript(script)) {
if (redeemScript === undefined) {
fail = true;
} else if (isP2WSHScript(redeemScript)) {
if (witnessScript === undefined) {
fail = true;
} else {
fail = !payments
.p2sh({
redeem: payments.p2wsh({
redeem: { output: witnessScript },
}),
})
.output.equals(script);
if (!fail) return witnessScript;
}
} else {
fail = !payments
.p2sh({
redeem: { output: redeemScript },
})
.output.equals(script);
if (!fail) return redeemScript;
}
} else if (isP2WSHScript(script)) {
if (witnessScript === undefined) {
fail = true;
} else {
fail = !payments
.p2wsh({
redeem: { output: witnessScript },
})
.output.equals(script);
if (!fail) return witnessScript;
}
}
if (fail) {
throw new Error('Incomplete script information');
}
return script;
}
function pubkeyInScript(pubkey, script) {
const pubkeyHash = crypto_1.hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
return decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
});
}
function classifyScript(script) {
if (isP2WPKH(script)) return 'witnesspubkeyhash';
if (isP2PKH(script)) return 'pubkeyhash';

141
test/psbt.spec.ts
View file

@ -1,7 +1,7 @@
import * as assert from 'assert';
import { describe, it } from 'mocha';
import { bip32, ECPair, networks as NETWORKS, Psbt } from '..';
import { bip32, ECPair, networks as NETWORKS, Psbt, payments } from '..';
import * as preFixtures from './fixtures/psbt.json';
@ -542,6 +542,143 @@ describe(`Psbt`, () => {
});
});
describe('inputHasPubkey', () => {
it('should throw', () => {
const psbt = new Psbt();
psbt.addInput({
hash:
'0000000000000000000000000000000000000000000000000000000000000000',
index: 0,
});
assert.throws(() => {
psbt.inputHasPubkey(0, Buffer.from([]));
}, new RegExp("Can't find pubkey in input without Utxo data"));
psbt.updateInput(0, {
witnessUtxo: {
value: 1337,
script: payments.p2sh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
},
});
assert.throws(() => {
psbt.inputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
delete psbt.data.inputs[0].witnessUtxo;
psbt.updateInput(0, {
witnessUtxo: {
value: 1337,
script: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
},
});
assert.throws(() => {
psbt.inputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
delete psbt.data.inputs[0].witnessUtxo;
psbt.updateInput(0, {
witnessUtxo: {
value: 1337,
script: payments.p2sh({
redeem: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}),
}).output!,
},
redeemScript: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
});
assert.throws(() => {
psbt.inputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
psbt.updateInput(0, {
witnessScript: Buffer.from([0x51]),
});
assert.doesNotThrow(() => {
psbt.inputHasPubkey(0, Buffer.from([0x51]));
});
});
});
describe('outputHasPubkey', () => {
it('should throw', () => {
const psbt = new Psbt();
psbt
.addInput({
hash:
'0000000000000000000000000000000000000000000000000000000000000000',
index: 0,
})
.addOutput({
script: payments.p2sh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
value: 1337,
});
assert.throws(() => {
psbt.outputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
(psbt as any).__CACHE.__TX.outs[0].script = payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}).output!;
assert.throws(() => {
psbt.outputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
(psbt as any).__CACHE.__TX.outs[0].script = payments.p2sh({
redeem: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}),
}).output!;
psbt.updateOutput(0, {
redeemScript: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
});
assert.throws(() => {
psbt.outputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
delete psbt.data.outputs[0].redeemScript;
psbt.updateOutput(0, {
witnessScript: Buffer.from([0x51]),
});
assert.throws(() => {
psbt.outputHasPubkey(0, Buffer.from([]));
}, new RegExp('Incomplete script information'));
psbt.updateOutput(0, {
redeemScript: payments.p2wsh({
redeem: { output: Buffer.from([0x51]) },
}).output!,
});
assert.doesNotThrow(() => {
psbt.outputHasPubkey(0, Buffer.from([0x51]));
});
});
});
describe('clone', () => {
it('Should clone a psbt exactly with no reference', () => {
const f = fixtures.clone;
@ -643,6 +780,8 @@ describe(`Psbt`, () => {
assert.throws(() => {
psbt.setVersion(3);
}, new RegExp('Can not modify transaction, signatures exist.'));
assert.strictEqual(psbt.inputHasPubkey(0, alice.publicKey), true);
assert.strictEqual(psbt.outputHasPubkey(0, alice.publicKey), false);
assert.strictEqual(
psbt.extractTransaction().toHex(),
'02000000013ebc8203037dda39d482bf41ff3be955996c50d9d4f7cfc3d2097a694a7' +

127
ts_src/psbt.ts
View file

@ -13,7 +13,7 @@ import {
TransactionInput,
TransactionOutput,
} from 'bip174/src/lib/interfaces';
import { checkForInput } from 'bip174/src/lib/utils';
import { checkForInput, checkForOutput } from 'bip174/src/lib/utils';
import { fromOutputScript, toOutputScript } from './address';
import { cloneBuffer, reverseBuffer } from './bufferutils';
import { hash160 } from './crypto';
@ -340,6 +340,16 @@ export class Psbt {
return this;
}
inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean {
const input = checkForInput(this.data.inputs, inputIndex);
return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
}
outputHasPubkey(outputIndex: number, pubkey: Buffer): boolean {
const output = checkForOutput(this.data.outputs, outputIndex);
return pubkeyInOutput(pubkey, output, outputIndex, this.__CACHE);
}
validateSignaturesOfAllInputs(): boolean {
checkForInput(this.data.inputs, 0); // making sure we have at least one
const results = range(this.data.inputs.length).map(idx =>
@ -849,6 +859,7 @@ const isP2PK = isPaymentFactory(payments.p2pk);
const isP2PKH = isPaymentFactory(payments.p2pkh);
const isP2WPKH = isPaymentFactory(payments.p2wpkh);
const isP2WSHScript = isPaymentFactory(payments.p2wsh);
const isP2SHScript = isPaymentFactory(payments.p2sh);
function check32Bit(num: number): void {
if (
@ -927,17 +938,7 @@ function checkScriptForPubkey(
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) {
if (!pubkeyInScript(pubkey, script)) {
throw new Error(
`Can not ${action} for this input with the key ${pubkey.toString('hex')}`,
);
@ -1560,6 +1561,108 @@ function nonWitnessUtxoTxFromCache(
return c[inputIndex];
}
function pubkeyInInput(
pubkey: Buffer,
input: PsbtInput,
inputIndex: number,
cache: PsbtCache,
): boolean {
let script: Buffer;
if (input.witnessUtxo !== undefined) {
script = input.witnessUtxo.script;
} else if (input.nonWitnessUtxo !== undefined) {
const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
cache,
input,
inputIndex,
);
script = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
} else {
throw new Error("Can't find pubkey in input without Utxo data");
}
const meaningfulScript = checkScripts(
script,
input.redeemScript,
input.witnessScript,
);
return pubkeyInScript(pubkey, meaningfulScript);
}
function pubkeyInOutput(
pubkey: Buffer,
output: PsbtOutput,
outputIndex: number,
cache: PsbtCache,
): boolean {
const script = cache.__TX.outs[outputIndex].script;
const meaningfulScript = checkScripts(
script,
output.redeemScript,
output.witnessScript,
);
return pubkeyInScript(pubkey, meaningfulScript);
}
function checkScripts(
script: Buffer,
redeemScript?: Buffer,
witnessScript?: Buffer,
): Buffer {
let fail = false;
if (isP2SHScript(script)) {
if (redeemScript === undefined) {
fail = true;
} else if (isP2WSHScript(redeemScript)) {
if (witnessScript === undefined) {
fail = true;
} else {
fail = !payments
.p2sh({
redeem: payments.p2wsh({
redeem: { output: witnessScript },
}),
})
.output!.equals(script);
if (!fail) return witnessScript;
}
} else {
fail = !payments
.p2sh({
redeem: { output: redeemScript },
})
.output!.equals(script);
if (!fail) return redeemScript;
}
} else if (isP2WSHScript(script)) {
if (witnessScript === undefined) {
fail = true;
} else {
fail = !payments
.p2wsh({
redeem: { output: witnessScript },
})
.output!.equals(script);
if (!fail) return witnessScript;
}
}
if (fail) {
throw new Error('Incomplete script information');
}
return script;
}
function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
const pubkeyHash = hash160(pubkey);
const decompiled = bscript.decompile(script);
if (decompiled === null) throw new Error('Unknown script error');
return decompiled.some(element => {
if (typeof element === 'number') return false;
return element.equals(pubkey) || element.equals(pubkeyHash);
});
}
function classifyScript(script: Buffer): string {
if (isP2WPKH(script)) return 'witnesspubkeyhash';
if (isP2PKH(script)) return 'pubkeyhash';

2
types/psbt.d.ts vendored
View file

@ -63,6 +63,8 @@ export declare class Psbt {
getFee(): number;
finalizeAllInputs(): this;
finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc): this;
inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean;
outputHasPubkey(outputIndex: number, pubkey: Buffer): boolean;
validateSignaturesOfAllInputs(): boolean;
validateSignaturesOfInput(inputIndex: number, pubkey?: Buffer): boolean;
signAllInputsHD(hdKeyPair: HDSigner, sighashTypes?: number[]): this;