Add getInputType

src/psbt.js

@@ -189,6 +189,7 @@ class Psbt {
       );
     }
     checkInputsForPartialSig(this.data.inputs, 'addInput');
+    if (inputData.witnessScript) checkInvalidP2WSH(inputData.witnessScript);
     const c = this.__CACHE;
     this.data.addInput(inputData);
     const txIn = c.__TX.ins[c.__TX.ins.length - 1];
@@ -285,6 +286,20 @@ class Psbt {
     this.data.clearFinalizedInput(inputIndex);
     return this;
   }
+  getInputType(inputIndex) {
+    const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+    const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);
+    const result = getMeaningfulScript(
+      script,
+      inputIndex,
+      'input',
+      input.redeemScript,
+      input.witnessScript,
+    );
+    const type = result.type === 'raw' ? '' : result.type + '-';
+    const mainType = classifyScript(result.meaningfulScript);
+    return type + mainType;
+  }
   inputHasPubkey(inputIndex, pubkey) {
     const input = utils_1.checkForInput(this.data.inputs, inputIndex);
     return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
@@ -538,6 +553,7 @@ class Psbt {
     return this;
   }
   updateInput(inputIndex, updateData) {
+    if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);
     this.data.updateInput(inputIndex, updateData);
     if (updateData.nonWitnessUtxo) {
       addNonWitnessTxCache(
@@ -924,7 +940,7 @@ function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
     input.redeemScript,
     input.witnessScript,
   );
-  if (['p2shp2wsh', 'p2wsh'].indexOf(type) >= 0) {
+  if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
     hash = unsignedTx.hashForWitnessV0(
       inputIndex,
       meaningfulScript,
@@ -1220,20 +1236,22 @@ function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
   }
   return c[inputIndex];
 }
-function pubkeyInInput(pubkey, input, inputIndex, cache) {
+function getScriptFromUtxo(inputIndex, input, cache) {
-  let script;
   if (input.witnessUtxo !== undefined) {
-    script = input.witnessUtxo.script;
+    return input.witnessUtxo.script;
   } else if (input.nonWitnessUtxo !== undefined) {
     const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
       cache,
       input,
       inputIndex,
     );
-    script = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
+    return nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
   } else {
     throw new Error("Can't find pubkey in input without Utxo data");
   }
+}
+function pubkeyInInput(pubkey, input, inputIndex, cache) {
+  const script = getScriptFromUtxo(inputIndex, input, cache);
   const { meaningfulScript } = getMeaningfulScript(
     script,
     inputIndex,
@@ -1275,9 +1293,11 @@ function getMeaningfulScript(
     meaningfulScript = witnessScript;
     checkRedeemScript(index, script, redeemScript, ioType);
     checkWitnessScript(index, redeemScript, witnessScript, ioType);
+    checkInvalidP2WSH(meaningfulScript);
   } else if (isP2WSH) {
     meaningfulScript = witnessScript;
     checkWitnessScript(index, script, witnessScript, ioType);
+    checkInvalidP2WSH(meaningfulScript);
   } else if (isP2SH) {
     meaningfulScript = redeemScript;
     checkRedeemScript(index, script, redeemScript, ioType);
@@ -1287,7 +1307,7 @@ function getMeaningfulScript(
   return {
     meaningfulScript,
     type: isP2SHP2WSH
-      ? 'p2shp2wsh'
+      ? 'p2sh-p2wsh'
       : isP2SH
       ? 'p2sh'
       : isP2WSH
@@ -1295,6 +1315,11 @@ function getMeaningfulScript(
       : 'raw',
   };
 }
+function checkInvalidP2WSH(script) {
+  if (isP2WPKH(script) || isP2SHScript(script)) {
+    throw new Error('P2WPKH or P2SH can not be contained within P2WSH');
+  }
+}
 function pubkeyInScript(pubkey, script) {
   const pubkeyHash = crypto_1.hash160(pubkey);
   const decompiled = bscript.decompile(script);

test/fixtures/psbt.json

@@ -313,6 +313,24 @@
         },
         "exception": "Invalid arguments for Psbt\\.addInput\\. Requires single object with at least \\[hash\\] and \\[index\\]"
       },
+      {
+        "description": "checks for invalid p2wsh witnessScript",
+        "inputData": {
+          "hash": "Buffer.from('000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f', 'hex')",
+          "index": 0,
+          "witnessScript": "Buffer.from('0014000102030405060708090a0b0c0d0e0f00010203', 'hex')"
+        },
+        "exception": "P2WPKH or P2SH can not be contained within P2WSH"
+      },
+      {
+        "description": "checks for invalid p2wsh witnessScript",
+        "inputData": {
+          "hash": "Buffer.from('000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f', 'hex')",
+          "index": 0,
+          "witnessScript": "Buffer.from('a914000102030405060708090a0b0c0d0e0f0001020387', 'hex')"
+        },
+        "exception": "P2WPKH or P2SH can not be contained within P2WSH"
+      },
       {
         "description": "should be equal",
         "inputData": {

test/psbt.spec.ts

@@ -542,6 +542,95 @@ describe(`Psbt`, () => {
     });
   });
 
+  describe('getInputType', () => {
+    const { publicKey } = ECPair.makeRandom();
+    const p2wpkhPub = (pubkey: Buffer): Buffer =>
+      payments.p2wpkh({
+        pubkey,
+      }).output!;
+    const p2pkhPub = (pubkey: Buffer): Buffer =>
+      payments.p2pkh({
+        pubkey,
+      }).output!;
+    const p2shOut = (output: Buffer): Buffer =>
+      payments.p2sh({
+        redeem: { output },
+      }).output!;
+    const p2wshOut = (output: Buffer): Buffer =>
+      payments.p2wsh({
+        redeem: { output },
+      }).output!;
+    const p2shp2wshOut = (output: Buffer): Buffer => p2shOut(p2wshOut(output));
+    const noOuter = (output: Buffer): Buffer => output;
+
+    function getInputTypeTest({
+      innerScript,
+      outerScript,
+      redeemGetter,
+      witnessGetter,
+      expectedType,
+    }: any): void {
+      const psbt = new Psbt();
+      psbt.addInput({
+        hash:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        index: 0,
+        witnessUtxo: {
+          script: outerScript(innerScript(publicKey)),
+          value: 2e3,
+        },
+        ...(redeemGetter ? { redeemScript: redeemGetter(publicKey) } : {}),
+        ...(witnessGetter ? { witnessScript: witnessGetter(publicKey) } : {}),
+      });
+      const type = psbt.getInputType(0);
+      assert.strictEqual(type, expectedType, 'incorrect input type');
+    }
+    [
+      {
+        innerScript: p2pkhPub,
+        outerScript: noOuter,
+        redeemGetter: null,
+        witnessGetter: null,
+        expectedType: 'pubkeyhash',
+      },
+      {
+        innerScript: p2wpkhPub,
+        outerScript: noOuter,
+        redeemGetter: null,
+        witnessGetter: null,
+        expectedType: 'witnesspubkeyhash',
+      },
+      {
+        innerScript: p2pkhPub,
+        outerScript: p2shOut,
+        redeemGetter: p2pkhPub,
+        witnessGetter: null,
+        expectedType: 'p2sh-pubkeyhash',
+      },
+      {
+        innerScript: p2wpkhPub,
+        outerScript: p2shOut,
+        redeemGetter: p2wpkhPub,
+        witnessGetter: null,
+        expectedType: 'p2sh-witnesspubkeyhash',
+      },
+      {
+        innerScript: p2pkhPub,
+        outerScript: p2wshOut,
+        redeemGetter: null,
+        witnessGetter: p2pkhPub,
+        expectedType: 'p2wsh-pubkeyhash',
+      },
+      {
+        innerScript: p2pkhPub,
+        outerScript: p2shp2wshOut,
+        redeemGetter: (pk: Buffer): Buffer => p2wshOut(p2pkhPub(pk)),
+        witnessGetter: p2pkhPub,
+        expectedType: 'p2sh-p2wsh-pubkeyhash',
+      },
+    ].forEach(getInputTypeTest);
+  });
+
   describe('inputHasPubkey', () => {
     it('should throw', () => {
       const psbt = new Psbt();

ts_src/psbt.ts

@@ -242,6 +242,7 @@ export class Psbt {
       );
     }
     checkInputsForPartialSig(this.data.inputs, 'addInput');
+    if (inputData.witnessScript) checkInvalidP2WSH(inputData.witnessScript);
     const c = this.__CACHE;
     this.data.addInput(inputData);
     const txIn = c.__TX.ins[c.__TX.ins.length - 1];
@@ -355,6 +356,21 @@ export class Psbt {
     return this;
   }
 
+  getInputType(inputIndex: number): AllScriptType {
+    const input = checkForInput(this.data.inputs, inputIndex);
+    const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);
+    const result = getMeaningfulScript(
+      script,
+      inputIndex,
+      'input',
+      input.redeemScript,
+      input.witnessScript,
+    );
+    const type = result.type === 'raw' ? '' : result.type + '-';
+    const mainType = classifyScript(result.meaningfulScript);
+    return (type + mainType) as AllScriptType;
+  }
+
   inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean {
     const input = checkForInput(this.data.inputs, inputIndex);
     return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
@@ -648,6 +664,7 @@ export class Psbt {
   }
 
   updateInput(inputIndex: number, updateData: PsbtInputUpdate): this {
+    if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);
     this.data.updateInput(inputIndex, updateData);
     if (updateData.nonWitnessUtxo) {
       addNonWitnessTxCache(
@@ -1215,7 +1232,7 @@ function getHashForSig(
     input.witnessScript,
   );
 
-  if (['p2shp2wsh', 'p2wsh'].indexOf(type) >= 0) {
+  if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
     hash = unsignedTx.hashForWitnessV0(
       inputIndex,
       meaningfulScript,
@@ -1572,25 +1589,32 @@ function nonWitnessUtxoTxFromCache(
   return c[inputIndex];
 }
 
-function pubkeyInInput(
+function getScriptFromUtxo(
-  pubkey: Buffer,
-  input: PsbtInput,
   inputIndex: number,
+  input: PsbtInput,
   cache: PsbtCache,
-): boolean {
+): Buffer {
-  let script: Buffer;
   if (input.witnessUtxo !== undefined) {
-    script = input.witnessUtxo.script;
+    return input.witnessUtxo.script;
   } else if (input.nonWitnessUtxo !== undefined) {
     const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
       cache,
       input,
       inputIndex,
     );
-    script = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
+    return nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;
   } else {
     throw new Error("Can't find pubkey in input without Utxo data");
   }
+}
+
+function pubkeyInInput(
+  pubkey: Buffer,
+  input: PsbtInput,
+  inputIndex: number,
+  cache: PsbtCache,
+): boolean {
+  const script = getScriptFromUtxo(inputIndex, input, cache);
   const { meaningfulScript } = getMeaningfulScript(
     script,
     inputIndex,
@@ -1626,7 +1650,7 @@ function getMeaningfulScript(
   witnessScript?: Buffer,
 ): {
   meaningfulScript: Buffer;
-  type: 'p2sh' | 'p2wsh' | 'p2shp2wsh' | 'raw';
+  type: 'p2sh' | 'p2wsh' | 'p2sh-p2wsh' | 'raw';
 } {
   const isP2SH = isP2SHScript(script);
   const isP2SHP2WSH = isP2SH && redeemScript && isP2WSHScript(redeemScript);
@@ -1645,9 +1669,11 @@ function getMeaningfulScript(
     meaningfulScript = witnessScript!;
     checkRedeemScript(index, script, redeemScript!, ioType);
     checkWitnessScript(index, redeemScript!, witnessScript!, ioType);
+    checkInvalidP2WSH(meaningfulScript);
   } else if (isP2WSH) {
     meaningfulScript = witnessScript!;
     checkWitnessScript(index, script, witnessScript!, ioType);
+    checkInvalidP2WSH(meaningfulScript);
   } else if (isP2SH) {
     meaningfulScript = redeemScript!;
     checkRedeemScript(index, script, redeemScript!, ioType);
@@ -1657,7 +1683,7 @@ function getMeaningfulScript(
   return {
     meaningfulScript,
     type: isP2SHP2WSH
-      ? 'p2shp2wsh'
+      ? 'p2sh-p2wsh'
       : isP2SH
       ? 'p2sh'
       : isP2WSH
@@ -1666,6 +1692,12 @@ function getMeaningfulScript(
   };
 }
 
+function checkInvalidP2WSH(script: Buffer): void {
+  if (isP2WPKH(script) || isP2SHScript(script)) {
+    throw new Error('P2WPKH or P2SH can not be contained within P2WSH');
+  }
+}
+
 function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
   const pubkeyHash = hash160(pubkey);
 
@@ -1678,7 +1710,32 @@ function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
   });
 }
 
-function classifyScript(script: Buffer): string {
+type AllScriptType =
+  | 'witnesspubkeyhash'
+  | 'pubkeyhash'
+  | 'multisig'
+  | 'pubkey'
+  | 'nonstandard'
+  | 'p2sh-witnesspubkeyhash'
+  | 'p2sh-pubkeyhash'
+  | 'p2sh-multisig'
+  | 'p2sh-pubkey'
+  | 'p2sh-nonstandard'
+  | 'p2wsh-pubkeyhash'
+  | 'p2wsh-multisig'
+  | 'p2wsh-pubkey'
+  | 'p2wsh-nonstandard'
+  | 'p2sh-p2wsh-pubkeyhash'
+  | 'p2sh-p2wsh-multisig'
+  | 'p2sh-p2wsh-pubkey'
+  | 'p2sh-p2wsh-nonstandard';
+type ScriptType =
+  | 'witnesspubkeyhash'
+  | 'pubkeyhash'
+  | 'multisig'
+  | 'pubkey'
+  | 'nonstandard';
+function classifyScript(script: Buffer): ScriptType {
   if (isP2WPKH(script)) return 'witnesspubkeyhash';
   if (isP2PKH(script)) return 'pubkeyhash';
   if (isP2MS(script)) return 'multisig';

types/psbt.d.ts

@@ -69,6 +69,7 @@ export declare class Psbt {
     getFee(): number;
     finalizeAllInputs(): this;
     finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc): this;
+    getInputType(inputIndex: number): AllScriptType;
     inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean;
     outputHasPubkey(outputIndex: number, pubkey: Buffer): boolean;
     validateSignaturesOfAllInputs(): boolean;
@@ -151,4 +152,5 @@ isP2WSH: boolean) => {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };
+declare type AllScriptType = 'witnesspubkeyhash' | 'pubkeyhash' | 'multisig' | 'pubkey' | 'nonstandard' | 'p2sh-witnesspubkeyhash' | 'p2sh-pubkeyhash' | 'p2sh-multisig' | 'p2sh-pubkey' | 'p2sh-nonstandard' | 'p2wsh-pubkeyhash' | 'p2wsh-multisig' | 'p2wsh-pubkey' | 'p2wsh-nonstandard' | 'p2sh-p2wsh-pubkeyhash' | 'p2sh-p2wsh-multisig' | 'p2sh-p2wsh-pubkey' | 'p2sh-p2wsh-nonstandard';
 export {};