@scure/btc-signer 1.7.0 → 1.8.0

package/src/payment.ts

@@ -1,9 +1,9 @@
 import { bech32, bech32m, type Coder, createBase58check, hex } from '@scure/base';
 import * as P from 'micro-packed';
-import { TaprootControlBlock, type TransactionInput } from './psbt.js';
-import { OpToNum, Script, type ScriptType, VarBytes } from './script.js';
-import * as u from './utils.js';
-import { type BTC_NETWORK, type Bytes, NETWORK } from './utils.js';
+import { TaprootControlBlock, type TransactionInput } from './psbt.ts';
+import { OpToNum, Script, type ScriptType, VarBytes } from './script.ts';
+import * as u from './utils.ts';
+import { type BTC_NETWORK, type Bytes, NETWORK } from './utils.ts';
 
 // We need following items:
 // - encode/decode output script
@@ -16,6 +16,7 @@ export type P2Ret = {
   address?: string;
   redeemScript?: Bytes;
   witnessScript?: Bytes;
+  hash?: Bytes;
 };
 
 // Pay to Anchor (P2A)
@@ -328,42 +329,79 @@ function uniqPubkey(pubkeys: Bytes[]) {
     map[key] = true;
   }
 }
+// We want narrow types inside p2* methods, but always want to type-check if they compatible with P2Ret here!
+// Also we use satisfies for additional check (ts 4.9+)
+type Extends<T, U> = T extends U ? T : never;
 
-// @ts-ignore
-export const p2pk = (pubkey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret => {
+export type P2PK = { type: 'pk'; script: Bytes };
+export const p2pk = (pubkey: Bytes, _network: BTC_NETWORK = NETWORK): Extends<P2PK, P2Ret> => {
   // network is unused
   if (!isValidPubkey(pubkey, u.PubT.ecdsa)) throw new Error('P2PK: invalid publicKey');
-  return {
-    type: 'pk',
-    script: OutScript.encode({ type: 'pk', pubkey }),
-  };
+  return { type: 'pk', script: OutScript.encode({ type: 'pk', pubkey }) } as const satisfies P2Ret;
 };
-export const p2pkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret => {
+
+export type P2PKH = { type: 'pkh'; script: Bytes; address: string; hash: Bytes };
+export const p2pkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): Extends<P2PKH, P2Ret> => {
   if (!isValidPubkey(publicKey, u.PubT.ecdsa)) throw new Error('P2PKH: invalid publicKey');
   const hash = u.hash160(publicKey);
   return {
     type: 'pkh',
     script: OutScript.encode({ type: 'pkh', hash }),
     address: Address(network).encode({ type: 'pkh', hash }),
-  };
+    hash,
+  } as const satisfies P2Ret;
 };
-export const p2sh = (child: P2Ret, network: BTC_NETWORK = NETWORK): P2Ret => {
+
+export type P2SHBase = {
+  type: 'sh';
+  redeemScript: Bytes;
+  script: Bytes;
+  address: string;
+  hash: Bytes;
+};
+export type P2SHWithWitness = P2SHBase & { witnessScript: Bytes };
+export type P2SHWithoutWitness = Omit<P2SHBase, 'witnessScript'>;
+export type P2SHReturn<T extends P2Ret> = T extends { witnessScript: Bytes }
+  ? P2SHWithWitness
+  : P2SHWithoutWitness;
+export const p2sh = <T extends P2Ret>(
+  child: T,
+  network: BTC_NETWORK = NETWORK
+): Extends<P2SHReturn<T>, P2Ret> => {
   // It is already tested inside noble-hashes and checkScript
   const cs = child.script;
   if (!u.isBytes(cs)) throw new Error(`Wrong script: ${typeof child.script}, expected Uint8Array`);
   const hash = u.hash160(cs);
   const script = OutScript.encode({ type: 'sh', hash });
   checkScript(script, cs, child.witnessScript);
-  const res: P2Ret = {
-    type: 'sh',
-    redeemScript: cs,
-    script: OutScript.encode({ type: 'sh', hash }),
-    address: Address(network).encode({ type: 'sh', hash }),
-  };
-  if (child.witnessScript) res.witnessScript = child.witnessScript;
-  return res;
+  if (child.witnessScript) {
+    return {
+      type: 'sh',
+      redeemScript: cs,
+      script: OutScript.encode({ type: 'sh', hash }),
+      address: Address(network).encode({ type: 'sh', hash }),
+      hash,
+      witnessScript: child.witnessScript,
+    } as Extends<P2SHReturn<T>, P2Ret> satisfies P2Ret;
+  } else {
+    return {
+      type: 'sh',
+      redeemScript: cs,
+      script: OutScript.encode({ type: 'sh', hash }),
+      address: Address(network).encode({ type: 'sh', hash }),
+      hash,
+    } as Extends<P2SHReturn<T>, P2Ret> satisfies P2Ret;
+  }
 };
-export const p2wsh = (child: P2Ret, network: BTC_NETWORK = NETWORK): P2Ret => {
+
+export type P2WSH = {
+  type: 'wsh';
+  witnessScript: Bytes;
+  script: Bytes;
+  address: string;
+  hash: Bytes;
+};
+export const p2wsh = (child: P2Ret, network: BTC_NETWORK = NETWORK): Extends<P2WSH, P2Ret> => {
   const cs = child.script;
   if (!u.isBytes(cs)) throw new Error(`Wrong script: ${typeof cs}, expected Uint8Array`);
   const hash = u.sha256(cs);
@@ -374,9 +412,15 @@ export const p2wsh = (child: P2Ret, network: BTC_NETWORK = NETWORK): P2Ret => {
     witnessScript: cs,
     script: OutScript.encode({ type: 'wsh', hash }),
     address: Address(network).encode({ type: 'wsh', hash }),
-  };
+    hash,
+  } as const satisfies P2Ret;
 };
-export const p2wpkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret => {
+
+export type P2WPKH = { type: 'wpkh'; script: Bytes; address: string; hash: Bytes };
+export const p2wpkh = (
+  publicKey: Bytes,
+  network: BTC_NETWORK = NETWORK
+): Extends<P2WPKH, P2Ret> => {
   if (!isValidPubkey(publicKey, u.PubT.ecdsa)) throw new Error('P2WPKH: invalid publicKey');
   if (publicKey.length === 65) throw new Error('P2WPKH: uncompressed public key');
   const hash = u.hash160(publicKey);
@@ -384,11 +428,21 @@ export const p2wpkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret
     type: 'wpkh',
     script: OutScript.encode({ type: 'wpkh', hash }),
     address: Address(network).encode({ type: 'wpkh', hash }),
-  };
+    hash,
+  } as const satisfies P2Ret;
 };
-export const p2ms = (m: number, pubkeys: Bytes[], allowSamePubkeys = false): P2Ret => {
+
+export type P2MS = { type: 'ms'; script: Bytes };
+export const p2ms = (
+  m: number,
+  pubkeys: Bytes[],
+  allowSamePubkeys = false
+): Extends<P2MS, P2Ret> => {
   if (!allowSamePubkeys) uniqPubkey(pubkeys);
-  return { type: 'ms', script: OutScript.encode({ type: 'ms', pubkeys, m }) };
+  return {
+    type: 'ms',
+    script: OutScript.encode({ type: 'ms', pubkeys, m }),
+  } as const satisfies P2Ret;
 };
 
 export type HashedTree =
@@ -438,19 +492,24 @@ function checkTaprootScript(
   }
 }
 
-export type P2TROut = P2Ret & {
+export type P2TR = {
+  type: 'tr';
+  script: Bytes;
+  address: string;
   tweakedPubkey: Bytes;
   tapInternalKey: Bytes;
-  tapMerkleRoot?: Bytes;
-  tapLeafScript?: TransactionInput['tapLeafScript'];
-  leaves?: TaprootLeaf[];
+};
+export type P2TR_TREE = P2TR & {
+  tapMerkleRoot: Bytes;
+  tapLeafScript: TransactionInput['tapLeafScript'];
+  leaves: TaprootLeaf[];
 };
 
 export type TaprootNode = {
   script: Bytes | string;
   leafVersion?: number;
   weight?: number;
-} & Partial<P2TROut>;
+} & Partial<P2TR_TREE>;
 export type TaprootScriptTree = TaprootNode | TaprootScriptTree[];
 export type TaprootScriptList = TaprootNode[];
 type _TaprootTreeInternal = {
@@ -562,13 +621,28 @@ export const tapLeafHash = (script: Bytes, version: number = TAP_LEAF_VERSION):
 // Works as key OR tree.
 // If we only have tree, need to add unspendable key, otherwise
 // complex multisig wallet can be spent by owner of key only. See TAPROOT_UNSPENDABLE_KEY
+export type P2TRRet<T> = T extends TaprootScriptTree ? P2TR_TREE : P2TR;
+export function p2tr(
+  internalPubKey: Bytes | string,
+  tree?: undefined,
+  network?: BTC_NETWORK,
+  allowUnknownOutputs?: boolean,
+  customScripts?: CustomScript[]
+): Extends<P2TR, P2Ret>;
+export function p2tr(
+  internalPubKey: Bytes | string,
+  tree: TaprootScriptTree,
+  network?: BTC_NETWORK,
+  allowUnknownOutputs?: boolean,
+  customScripts?: CustomScript[]
+): Extends<P2TR_TREE, P2Ret>;
 export function p2tr(
   internalPubKey?: Bytes | string,
   tree?: TaprootScriptTree,
   network: BTC_NETWORK = NETWORK,
   allowUnknownOutputs = false,
   customScripts?: CustomScript[]
-): P2TROut {
+): Extends<P2TR & Partial<P2TR_TREE>, P2Ret> {
   // Unspendable
   if (!internalPubKey && !tree) throw new Error('p2tr: should have pubKey or scriptTree (or both)');
   const pubKey =
@@ -576,14 +650,13 @@ export function p2tr(
       ? hex.decode(internalPubKey)
       : internalPubKey || u.TAPROOT_UNSPENDABLE_KEY;
   if (!isValidPubkey(pubKey, u.PubT.schnorr)) throw new Error('p2tr: non-schnorr pubkey');
-  let hashedTree = tree
-    ? taprootAddPath(taprootHashTree(tree, pubKey, allowUnknownOutputs, customScripts))
-    : undefined;
-  const tapMerkleRoot = hashedTree ? hashedTree.hash : undefined;
-  const [tweakedPubkey, parity] = u.taprootTweakPubkey(pubKey, tapMerkleRoot || P.EMPTY);
-  let leaves;
-  if (hashedTree) {
-    leaves = taprootWalkTree(hashedTree).map((l) => ({
+  if (tree) {
+    let hashedTree = taprootAddPath(
+      taprootHashTree(tree, pubKey, allowUnknownOutputs, customScripts)
+    );
+    const tapMerkleRoot = hashedTree.hash;
+    const [tweakedPubkey, parity] = u.taprootTweakPubkey(pubKey, tapMerkleRoot);
+    const leaves = taprootWalkTree(hashedTree).map((l) => ({
       ...l,
       controlBlock: TaprootControlBlock.encode({
         version: (l.version || TAP_LEAF_VERSION) + parity,
@@ -591,28 +664,33 @@ export function p2tr(
         merklePath: l.path,
       }),
     }));
+    return {
+      type: 'tr',
+      script: OutScript.encode({ type: 'tr', pubkey: tweakedPubkey }),
+      address: Address(network).encode({ type: 'tr', pubkey: tweakedPubkey }),
+      // For tests
+      tweakedPubkey,
+      // PSBT stuff
+      tapInternalKey: pubKey,
+      leaves,
+      tapLeafScript: leaves.map((l) => [
+        TaprootControlBlock.decode(l.controlBlock),
+        u.concatBytes(l.script, new Uint8Array([l.version || TAP_LEAF_VERSION])),
+      ]),
+      tapMerkleRoot,
+    } as const satisfies P2TR_TREE;
+  } else {
+    const tweakedPubkey = u.taprootTweakPubkey(pubKey, P.EMPTY)[0];
+    return {
+      type: 'tr',
+      script: OutScript.encode({ type: 'tr', pubkey: tweakedPubkey }),
+      address: Address(network).encode({ type: 'tr', pubkey: tweakedPubkey }),
+      // For tests
+      tweakedPubkey,
+      // PSBT stuff
+      tapInternalKey: pubKey,
+    } as const satisfies P2TR;
   }
-  let tapLeafScript: TransactionInput['tapLeafScript'];
-  if (leaves) {
-    tapLeafScript = leaves.map((l) => [
-      TaprootControlBlock.decode(l.controlBlock),
-      u.concatBytes(l.script, new Uint8Array([l.version || TAP_LEAF_VERSION])),
-    ]);
-  }
-  const res: P2TROut = {
-    type: 'tr',
-    script: OutScript.encode({ type: 'tr', pubkey: tweakedPubkey }),
-    address: Address(network).encode({ type: 'tr', pubkey: tweakedPubkey }),
-    // For tests
-    tweakedPubkey,
-    // PSBT stuff
-    tapInternalKey: pubKey,
-  };
-  // Just in case someone would want to select a specific script
-  if (leaves) res.leaves = leaves;
-  if (tapLeafScript) res.tapLeafScript = tapLeafScript;
-  if (tapMerkleRoot) res.tapMerkleRoot = tapMerkleRoot;
-  return res;
 }
 
 // Returns all combinations of size M from lst
@@ -651,29 +729,37 @@ export function combinations<T>(m: number, list: T[]): T[][] {
  * Takes O(n^2) if m != n. 99-of-100 is ok, 5-of-100 is not.
  * `2-of-[A,B,C] => [A,B] | [A,C] | [B,C]`
  */
-export const p2tr_ns = (m: number, pubkeys: Bytes[], allowSamePubkeys = false): P2Ret[] => {
+export type P2TR_NS = { type: 'tr_ns'; script: Bytes };
+export const p2tr_ns = (
+  m: number,
+  pubkeys: Bytes[],
+  allowSamePubkeys = false
+): Extends<P2TR_NS, P2Ret>[] => {
   if (!allowSamePubkeys) uniqPubkey(pubkeys);
-  return combinations(m, pubkeys).map((i) => ({
-    type: 'tr_ns',
-    script: OutScript.encode({ type: 'tr_ns', pubkeys: i }),
-  }));
+  return combinations(m, pubkeys).map(
+    (i) =>
+      ({
+        type: 'tr_ns',
+        script: OutScript.encode({ type: 'tr_ns', pubkeys: i }),
+      }) as const
+  ) satisfies P2Ret[];
 };
 // Taproot public key (case of p2tr_ns)
-export const p2tr_pk = (pubkey: Bytes): P2Ret => p2tr_ns(1, [pubkey], undefined)[0];
+export type P2TR_PK = P2TR_NS;
+export const p2tr_pk = (pubkey: Bytes): Extends<P2TR_PK, P2Ret> =>
+  p2tr_ns(1, [pubkey], undefined)[0] satisfies P2Ret;
 
+export type P2TR_MS = { type: 'tr_ms'; script: Bytes };
 export function p2tr_ms(
   m: number,
   pubkeys: Bytes[],
   allowSamePubkeys = false
-): {
-  type: string;
-  script: Uint8Array;
-} {
+): Extends<P2TR_MS, P2Ret> {
   if (!allowSamePubkeys) uniqPubkey(pubkeys);
   return {
     type: 'tr_ms',
     script: OutScript.encode({ type: 'tr_ms', pubkeys, m }),
-  };
+  } as const satisfies P2Ret;
 }
 
 // Simple pubkey address, without complex scripts
@@ -691,8 +777,7 @@ export function getAddress(
   throw new Error(`getAddress: unknown type=${type}`);
 }
 
-export const _sortPubkeys = (pubkeys: Bytes[]): Uint8Array[] =>
-  Array.from(pubkeys).sort(u.compareBytes);
+export const _sortPubkeys = (pubkeys: Bytes[]): Bytes[] => Array.from(pubkeys).sort(u.compareBytes);
 
 export function multisig(
   m: number,

package/src/psbt.ts

@@ -8,9 +8,8 @@ import {
   RawTx,
   RawWitness,
   VarBytes,
-} from './script.js';
-import { Transaction } from './transaction.js'; // circular
-import { type Bytes, compareBytes, equalBytes, PubT, validatePubkey } from './utils.js';
+} from './script.ts';
+import { type Bytes, compareBytes, equalBytes, PubT, validatePubkey } from './utils.ts';
 
 // PSBT BIP174, BIP370, BIP371
 
@@ -282,17 +281,6 @@ export const PSBTInputCoder = P.validate(PSBTKeyMap(PSBTInput), (i) => {
     (i.requiredHeightLocktime <= 0 || i.requiredHeightLocktime >= 500000000)
   )
     throw new Error(`validateInput: wrong heighLocktime=${i.requiredHeightLocktime}`);
-
-  if (i.nonWitnessUtxo && i.index !== undefined) {
-    const last = i.nonWitnessUtxo.outputs.length - 1;
-    if (i.index > last) throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);
-    const prevOut = i.nonWitnessUtxo.outputs[i.index];
-    if (
-      i.witnessUtxo &&
-      (!equalBytes(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount)
-    )
-      throw new Error('validateInput: witnessUtxo different from nonWitnessUtxo');
-  }
   if (i.tapLeafScript) {
     // tap leaf version appears here twice: in control block and at the end of script
     for (const [k, v] of i.tapLeafScript) {
@@ -302,28 +290,6 @@ export const PSBTInputCoder = P.validate(PSBTKeyMap(PSBTInput), (i) => {
         throw new Error('validateInput: tapLeafScript version has parity bit!');
     }
   }
-  // Validate txid for nonWitnessUtxo is correct
-  if (i.nonWitnessUtxo && i.index !== undefined && i.txid) {
-    const outputs = i.nonWitnessUtxo.outputs;
-    if (outputs.length - 1 < i.index) throw new Error('nonWitnessUtxo: incorect output index');
-    // At this point, we are using previous tx output to create new input.
-    // Script safety checks are unnecessary:
-    // - User has no control over previous tx. If somebody send money in same tx
-    //   as unspendable output, we still want user able to spend money
-    // - We still want some checks to notify user about possible errors early
-    //   in case user wants to use wrong input by mistake
-    // - Worst case: tx will be rejected by nodes. Still better than disallowing user
-    //   to spend real input, no matter how broken it looks
-    const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo), {
-      allowUnknownOutputs: true,
-      disableScriptCheck: true,
-      allowUnknownInputs: true,
-    });
-    const txid = hex.encode(i.txid);
-    // PSBTv2 vectors have non-final tx in inputs
-    if (tx.isFinal && tx.id !== txid)
-      throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
-  }
   return i;
 });
 

package/src/script.ts

@@ -1,5 +1,5 @@
 import * as P from 'micro-packed';
-import { isBytes } from './utils.js';
+import { isBytes } from './utils.ts';
 
 export const MAX_SCRIPT_BYTE_LENGTH = 520;
 

package/src/transaction.ts

@@ -1,7 +1,7 @@
 import { hex } from '@scure/base';
 import * as P from 'micro-packed';
-import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
-import * as psbt from './psbt.js'; // circular
+import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.ts';
+import * as psbt from './psbt.ts';
 import {
   CompactSizeLen,
   RawOldTx,
@@ -10,16 +10,16 @@ import {
   RawWitness,
   Script,
   VarBytes,
-} from './script.js';
-import * as u from './utils.js';
-import { type Bytes, NETWORK, concatBytes, equalBytes, isBytes } from './utils.js';
-import { getInputType, getPrevOut, normalizeInput, toVsize } from './utxo.js'; // circular
+} from './script.ts';
+import * as u from './utils.ts';
+import { type Bytes, NETWORK, concatBytes, equalBytes, isBytes } from './utils.ts';
 
 const EMPTY32 = new Uint8Array(32);
 const EMPTY_OUTPUT: P.UnwrapCoder<typeof RawOutput> = {
   amount: 0xffffffffffffffffn,
   script: P.EMPTY,
 };
+export const toVsize = (weight: number): number => Math.ceil(weight / 4);
 
 // @scure/bip32 interface
 interface HDKey {
@@ -230,6 +230,146 @@ function validateOpts(opts: TxOpts): Readonly<TxOpts> {
   return Object.freeze(_opts);
 }
 
+// NOTE: we cannot do this inside PSBTInput coder, because there is no index/txid at this point!
+function validateInput(i: psbt.TransactionInput): psbt.TransactionInput {
+  if (i.nonWitnessUtxo && i.index !== undefined) {
+    const last = i.nonWitnessUtxo.outputs.length - 1;
+    if (i.index > last) throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);
+    const prevOut = i.nonWitnessUtxo.outputs[i.index];
+    if (
+      i.witnessUtxo &&
+      (!equalBytes(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount)
+    )
+      throw new Error('validateInput: witnessUtxo different from nonWitnessUtxo');
+    if (i.txid) {
+      const outputs = i.nonWitnessUtxo.outputs;
+      if (outputs.length - 1 < i.index) throw new Error('nonWitnessUtxo: incorect output index');
+      // At this point, we are using previous tx output to create new input.
+      // Script safety checks are unnecessary:
+      // - User has no control over previous tx. If somebody send money in same tx
+      //   as unspendable output, we still want user able to spend money
+      // - We still want some checks to notify user about possible errors early
+      //   in case user wants to use wrong input by mistake
+      // - Worst case: tx will be rejected by nodes. Still better than disallowing user
+      //   to spend real input, no matter how broken it looks
+      const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo), {
+        allowUnknownOutputs: true,
+        disableScriptCheck: true,
+        allowUnknownInputs: true,
+      });
+      const txid = hex.encode(i.txid);
+      // PSBTv2 vectors have non-final tx in inputs
+      if (tx.isFinal && tx.id !== txid)
+        throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
+    }
+  }
+  return i;
+}
+
+export type PSBTInputs = psbt.PSBTKeyMapKeys<typeof psbt.PSBTInput>;
+
+// Normalizes input
+export function getPrevOut(input: psbt.TransactionInput): P.UnwrapCoder<typeof RawOutput> {
+  if (input.nonWitnessUtxo) {
+    if (input.index === undefined) throw new Error('Unknown input index');
+    return input.nonWitnessUtxo.outputs[input.index];
+  } else if (input.witnessUtxo) return input.witnessUtxo;
+  else throw new Error('Cannot find previous output info');
+}
+
+export function normalizeInput(
+  i: psbt.TransactionInputUpdate,
+  cur?: psbt.TransactionInput,
+  allowedFields?: (keyof psbt.TransactionInput)[],
+  disableScriptCheck = false,
+  allowUnknown = false
+): psbt.TransactionInput {
+  let { nonWitnessUtxo, txid } = i;
+  // String support for common fields. We usually prefer Uint8Array to avoid errors
+  // like hex looking string accidentally passed, however, in case of nonWitnessUtxo
+  // it is better to expect string, since constructing this complex object will be
+  // difficult for user
+  if (typeof nonWitnessUtxo === 'string') nonWitnessUtxo = hex.decode(nonWitnessUtxo);
+  if (isBytes(nonWitnessUtxo)) nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);
+  if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)
+    nonWitnessUtxo = cur?.nonWitnessUtxo;
+  if (typeof txid === 'string') txid = hex.decode(txid);
+  // TODO: if we have nonWitnessUtxo, we can extract txId from here
+  if (txid === undefined) txid = cur?.txid;
+  let res: PSBTInputs = { ...cur, ...i, nonWitnessUtxo, txid };
+  if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined) delete res.nonWitnessUtxo;
+  if (res.sequence === undefined) res.sequence = DEFAULT_SEQUENCE;
+  if (res.tapMerkleRoot === null) delete res.tapMerkleRoot;
+  res = psbt.mergeKeyMap(psbt.PSBTInput, res, cur, allowedFields, allowUnknown);
+  psbt.PSBTInputCoder.encode(res); // Validates that everything is correct at this point
+
+  let prevOut;
+  if (res.nonWitnessUtxo && res.index !== undefined)
+    prevOut = res.nonWitnessUtxo.outputs[res.index];
+  else if (res.witnessUtxo) prevOut = res.witnessUtxo;
+  if (prevOut && !disableScriptCheck)
+    checkScript(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
+  return res;
+}
+
+export function getInputType(input: psbt.TransactionInput, allowLegacyWitnessUtxo = false) {
+  let txType = 'legacy';
+  let defaultSighash = SignatureHash.ALL;
+  const prevOut = getPrevOut(input);
+  const first = OutScript.decode(prevOut.script);
+  let type = first.type;
+  let cur = first;
+  const stack = [first];
+  if (first.type === 'tr') {
+    defaultSighash = SignatureHash.DEFAULT;
+    return {
+      txType: 'taproot',
+      type: 'tr',
+      last: first,
+      lastScript: prevOut.script,
+      defaultSighash,
+      sighash: input.sighashType || defaultSighash,
+    };
+  } else {
+    if (first.type === 'wpkh' || first.type === 'wsh') txType = 'segwit';
+    if (first.type === 'sh') {
+      if (!input.redeemScript) throw new Error('inputType: sh without redeemScript');
+      let child = OutScript.decode(input.redeemScript);
+      if (child.type === 'wpkh' || child.type === 'wsh') txType = 'segwit';
+      stack.push(child);
+      cur = child;
+      type += `-${child.type}`;
+    }
+    // wsh can be inside sh
+    if (cur.type === 'wsh') {
+      if (!input.witnessScript) throw new Error('inputType: wsh without witnessScript');
+      let child = OutScript.decode(input.witnessScript);
+      if (child.type === 'wsh') txType = 'segwit';
+      stack.push(child);
+      cur = child;
+      type += `-${child.type}`;
+    }
+    const last = stack[stack.length - 1];
+    if (last.type === 'sh' || last.type === 'wsh')
+      throw new Error('inputType: sh/wsh cannot be terminal type');
+    const lastScript = OutScript.encode(last);
+    const res = {
+      type,
+      txType,
+      last,
+      lastScript,
+      defaultSighash,
+      sighash: input.sighashType || defaultSighash,
+    };
+    if (txType === 'legacy' && !allowLegacyWitnessUtxo && !input.nonWitnessUtxo) {
+      throw new Error(
+        `Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`
+      );
+    }
+    return res;
+  }
+}
+
 export class Transaction {
   private global: psbt.PSBTKeyMapKeys<typeof psbt.PSBTGlobal> = {};
   private inputs: psbt.TransactionInput[] = []; // use getInput()
@@ -277,11 +417,13 @@ export class Transaction {
     const tx = new Transaction({ ...opts, version, lockTime, PSBTVersion });
     // We need slice here, because otherwise
     const inputCount = PSBTVersion === 0 ? unsigned?.inputs.length : parsed.global.inputCount;
-    tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) => ({
-      finalScriptSig: P.EMPTY,
-      ...parsed.global.unsignedTx?.inputs[j],
-      ...i,
-    }));
+    tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) =>
+      validateInput({
+        finalScriptSig: P.EMPTY,
+        ...parsed.global.unsignedTx?.inputs[j],
+        ...i,
+      })
+    );
     const outputCount = PSBTVersion === 0 ? unsigned?.outputs.length : parsed.global.outputCount;
     tx.outputs = parsed.outputs.slice(0, outputCount).map((i, j) => ({
       ...i,
@@ -299,7 +441,9 @@ export class Transaction {
     //     'PSBT version=0 export for transaction without inputs disabled, please use version=2. Please check `toPSBT` method for explanation.'
     //   );
     // }
-    const inputs = this.inputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i));
+    const inputs = this.inputs.map((i) =>
+      validateInput(psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i))
+    );
     for (const inp of inputs) {
       // Don't serialize empty fields
       if (inp.partialSig && !inp.partialSig.length) delete inp.partialSig;