@scure/btc-signer 1.5.0 → 1.7.0

package/src/payment.ts

@@ -1,9 +1,9 @@
-import { Coder, hex, bech32, bech32m, createBase58check } from '@scure/base';
+import { bech32, bech32m, type Coder, createBase58check, hex } from '@scure/base';
 import * as P from 'micro-packed';
-import { TaprootControlBlock, TransactionInput } from './psbt.js';
-import { OpToNum, ScriptType, Script, VarBytes } from './script.js';
-import { Bytes, NETWORK } from './utils.js';
+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';
 
 // We need following items:
 // - encode/decode output script
@@ -18,6 +18,20 @@ export type P2Ret = {
   witnessScript?: Bytes;
 };
 
+// Pay to Anchor (P2A)
+type OutP2AType = { type: 'p2a'; script: Bytes };
+const OutP2A: Coder<OptScript, OutP2AType | undefined> = {
+  encode(from: ScriptType): OutP2AType | undefined {
+    if (from.length !== 2 || from[0] !== 1 || !u.isBytes(from[1]) || hex.encode(from[1]) !== '4e73')
+      return;
+    return { type: 'p2a', script: Script.encode(from) };
+  },
+  decode: (to: OutP2AType): OptScript => {
+    if (to.type !== 'p2a') return;
+    return [1, hex.decode('4e73')];
+  },
+};
+
 // Public Key (P2PK)
 type OutPKType = { type: 'pk'; pubkey: Bytes };
 export type OptScript = ScriptType | undefined;
@@ -189,6 +203,7 @@ const OutUnknown: Coder<OptScript, OutUnknownType | undefined> = {
 // /Payments
 
 const OutScripts = [
+  OutP2A,
   OutPK,
   OutPKH,
   OutSH,
@@ -224,7 +239,22 @@ export type CustomScript = Coder<OptScript, CustomScriptOut | undefined> & {
 };
 
 // We can validate this once, because of packed & coders
-export const OutScript = P.validate(_OutScript, (i) => {
+export const OutScript: P.CoderType<
+  NonNullable<
+    | OutP2AType
+    | OutPKType
+    | OutPKHType
+    | OutSHType
+    | OutWSHType
+    | OutWPKHType
+    | OutMSType
+    | OutTRType
+    | OutTRNSType
+    | OutTRMSType
+    | OutUnknownType
+    | undefined
+  >
+> = P.validate(_OutScript, (i) => {
   if (i.type === 'pk' && !isValidPubkey(i.pubkey, u.PubT.ecdsa))
     throw new Error('OutScript/pk: wrong key');
   if (
@@ -267,7 +297,7 @@ function checkWSH(s: OutWSHType, witnessScript: Bytes) {
     throw new Error(`checkScript: P2${w.type} cannot be wrapped in P2WSH`);
 }
 
-export function checkScript(script?: Bytes, redeemScript?: Bytes, witnessScript?: Bytes) {
+export function checkScript(script?: Bytes, redeemScript?: Bytes, witnessScript?: Bytes): void {
   if (script) {
     const s = OutScript.decode(script);
     // ms||pk maybe work, but there will be no address, hard to spend
@@ -300,7 +330,7 @@ function uniqPubkey(pubkeys: Bytes[]) {
 }
 
 // @ts-ignore
-export const p2pk = (pubkey: Bytes, network = NETWORK): P2Ret => {
+export const p2pk = (pubkey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret => {
   // network is unused
   if (!isValidPubkey(pubkey, u.PubT.ecdsa)) throw new Error('P2PK: invalid publicKey');
   return {
@@ -308,7 +338,7 @@ export const p2pk = (pubkey: Bytes, network = NETWORK): P2Ret => {
     script: OutScript.encode({ type: 'pk', pubkey }),
   };
 };
-export const p2pkh = (publicKey: Bytes, network = NETWORK): P2Ret => {
+export const p2pkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): P2Ret => {
   if (!isValidPubkey(publicKey, u.PubT.ecdsa)) throw new Error('P2PKH: invalid publicKey');
   const hash = u.hash160(publicKey);
   return {
@@ -317,7 +347,7 @@ export const p2pkh = (publicKey: Bytes, network = NETWORK): P2Ret => {
     address: Address(network).encode({ type: 'pkh', hash }),
   };
 };
-export const p2sh = (child: P2Ret, network = NETWORK): P2Ret => {
+export const p2sh = (child: P2Ret, network: BTC_NETWORK = NETWORK): 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`);
@@ -333,7 +363,7 @@ export const p2sh = (child: P2Ret, network = NETWORK): P2Ret => {
   if (child.witnessScript) res.witnessScript = child.witnessScript;
   return res;
 };
-export const p2wsh = (child: P2Ret, network = NETWORK): P2Ret => {
+export const p2wsh = (child: P2Ret, network: BTC_NETWORK = NETWORK): P2Ret => {
   const cs = child.script;
   if (!u.isBytes(cs)) throw new Error(`Wrong script: ${typeof cs}, expected Uint8Array`);
   const hash = u.sha256(cs);
@@ -346,7 +376,7 @@ export const p2wsh = (child: P2Ret, network = NETWORK): P2Ret => {
     address: Address(network).encode({ type: 'wsh', hash }),
   };
 };
-export const p2wpkh = (publicKey: Bytes, network = NETWORK): P2Ret => {
+export const p2wpkh = (publicKey: Bytes, network: BTC_NETWORK = NETWORK): 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);
@@ -361,7 +391,7 @@ export const p2ms = (m: number, pubkeys: Bytes[], allowSamePubkeys = false): P2R
   return { type: 'ms', script: OutScript.encode({ type: 'ms', pubkeys, m }) };
 };
 
-type HashedTree =
+export type HashedTree =
   | { type: 'leaf'; version?: number; script: Bytes; hash: Bytes }
   | { type: 'branch'; left: HashedTree; right: HashedTree; hash: Bytes };
 function checkTaprootScript(
@@ -409,9 +439,9 @@ function checkTaprootScript(
 }
 
 export type P2TROut = P2Ret & {
-  tweakedPubkey: Uint8Array;
-  tapInternalKey: Uint8Array;
-  tapMerkleRoot?: Uint8Array;
+  tweakedPubkey: Bytes;
+  tapInternalKey: Bytes;
+  tapMerkleRoot?: Bytes;
   tapLeafScript?: TransactionInput['tapLeafScript'];
   leaves?: TaprootLeaf[];
 };
@@ -451,7 +481,7 @@ export function taprootListToTree(taprootList: TaprootScriptList): TaprootScript
   return (last?.childs || last) as TaprootScriptTree;
 }
 
-type TaprootLeaf = {
+export type TaprootLeaf = {
   type: 'leaf';
   version?: number;
   script: Bytes;
@@ -459,7 +489,7 @@ type TaprootLeaf = {
   path: Bytes[];
 };
 
-type HashedTreeWithPath =
+export type HashedTreeWithPath =
   | TaprootLeaf
   | {
       type: 'branch';
@@ -526,7 +556,7 @@ function taprootHashTree(
 }
 
 export const TAP_LEAF_VERSION = 0xc0;
-export const tapLeafHash = (script: Bytes, version = TAP_LEAF_VERSION) =>
+export const tapLeafHash = (script: Bytes, version: number = TAP_LEAF_VERSION): Bytes =>
   u.tagSchnorr('TapLeaf', new Uint8Array([version]), VarBytes.encode(script));
 
 // Works as key OR tree.
@@ -535,7 +565,7 @@ export const tapLeafHash = (script: Bytes, version = TAP_LEAF_VERSION) =>
 export function p2tr(
   internalPubKey?: Bytes | string,
   tree?: TaprootScriptTree,
-  network = NETWORK,
+  network: BTC_NETWORK = NETWORK,
   allowUnknownOutputs = false,
   customScripts?: CustomScript[]
 ): P2TROut {
@@ -631,7 +661,14 @@ export const p2tr_ns = (m: number, pubkeys: Bytes[], allowSamePubkeys = false):
 // Taproot public key (case of p2tr_ns)
 export const p2tr_pk = (pubkey: Bytes): P2Ret => p2tr_ns(1, [pubkey], undefined)[0];
 
-export function p2tr_ms(m: number, pubkeys: Bytes[], allowSamePubkeys = false) {
+export function p2tr_ms(
+  m: number,
+  pubkeys: Bytes[],
+  allowSamePubkeys = false
+): {
+  type: string;
+  script: Uint8Array;
+} {
   if (!allowSamePubkeys) uniqPubkey(pubkeys);
   return {
     type: 'tr_ms',
@@ -640,7 +677,11 @@ export function p2tr_ms(m: number, pubkeys: Bytes[], allowSamePubkeys = false) {
 }
 
 // Simple pubkey address, without complex scripts
-export function getAddress(type: 'pkh' | 'wpkh' | 'tr', privKey: Bytes, network = NETWORK) {
+export function getAddress(
+  type: 'pkh' | 'wpkh' | 'tr',
+  privKey: Bytes,
+  network: BTC_NETWORK = NETWORK
+): string | undefined {
   if (type === 'tr') {
     return p2tr(u.pubSchnorr(privKey), undefined, network).address;
   }
@@ -650,20 +691,26 @@ export function getAddress(type: 'pkh' | 'wpkh' | 'tr', privKey: Bytes, network
   throw new Error(`getAddress: unknown type=${type}`);
 }
 
-export const _sortPubkeys = (pubkeys: Bytes[]) => Array.from(pubkeys).sort(u.compareBytes);
+export const _sortPubkeys = (pubkeys: Bytes[]): Uint8Array[] =>
+  Array.from(pubkeys).sort(u.compareBytes);
 
 export function multisig(
   m: number,
   pubkeys: Bytes[],
   sorted = false,
   witness = false,
-  network = NETWORK
-) {
+  network: BTC_NETWORK = NETWORK
+): P2Ret {
   const ms = p2ms(m, sorted ? _sortPubkeys(pubkeys) : pubkeys);
   return witness ? p2wsh(ms, network) : p2sh(ms, network);
 }
 
-export function sortedMultisig(m: number, pubkeys: Bytes[], witness = false, network = NETWORK) {
+export function sortedMultisig(
+  m: number,
+  pubkeys: Bytes[],
+  witness = false,
+  network: BTC_NETWORK = NETWORK
+): P2Ret {
   return multisig(m, pubkeys, true, witness, network);
 }
 
@@ -686,7 +733,7 @@ function formatKey(hashed: Bytes, prefix: number[]): string {
   return base58check.encode(u.concatBytes(Uint8Array.from(prefix), hashed));
 }
 
-export function WIF(network = NETWORK): Coder<Bytes, string> {
+export function WIF(network: BTC_NETWORK = NETWORK): Coder<Bytes, string> {
   return {
     encode(privKey: Bytes) {
       const compressed = u.concatBytes(privKey, new Uint8Array([0x01]));
@@ -705,7 +752,7 @@ export function WIF(network = NETWORK): Coder<Bytes, string> {
 }
 
 // Returns OutType, which can be used to create outscript
-export function Address(network = NETWORK) {
+export function Address(network: BTC_NETWORK = NETWORK) {
   return {
     encode(from: P.UnwrapCoder<OutScriptType>): string {
       const { type } = from;

package/src/psbt.ts

@@ -1,16 +1,27 @@
 import { hex } from '@scure/base';
 import * as P from 'micro-packed';
-import { CompactSize, CompactSizeLen, VarBytes } from './script.js';
-import { RawOutput, RawTx, RawOldTx, RawWitness } from './script.js';
+import {
+  CompactSize,
+  CompactSizeLen,
+  RawOldTx,
+  RawOutput,
+  RawTx,
+  RawWitness,
+  VarBytes,
+} from './script.js';
 import { Transaction } from './transaction.js'; // circular
-import { Bytes, compareBytes, PubT, validatePubkey, equalBytes } from './utils.js';
+import { type Bytes, compareBytes, equalBytes, PubT, validatePubkey } from './utils.js';
 
 // PSBT BIP174, BIP370, BIP371
 
 // Can be 33 or 64 bytes
-const PubKeyECDSA = P.validate(P.bytes(null), (pub) => validatePubkey(pub, PubT.ecdsa));
-const PubKeySchnorr = P.validate(P.bytes(32), (pub) => validatePubkey(pub, PubT.schnorr));
-const SignatureSchnorr = P.validate(P.bytes(null), (sig) => {
+const PubKeyECDSA: P.CoderType<Uint8Array> = P.validate(P.bytes(null), (pub) =>
+  validatePubkey(pub, PubT.ecdsa)
+);
+const PubKeySchnorr: P.CoderType<Uint8Array> = P.validate(P.bytes(32), (pub) =>
+  validatePubkey(pub, PubT.schnorr)
+);
+const SignatureSchnorr: P.CoderType<Uint8Array> = P.validate(P.bytes(null), (sig) => {
   if (sig.length !== 64 && sig.length !== 65)
     throw new Error('Schnorr signature should be 64 or 65 bytes long');
   return sig;
@@ -51,9 +62,9 @@ const tapTree = P.array(
   })
 );
 
-const BytesInf = P.bytes(null); // Bytes will conflict with Bytes type
-const Bytes20 = P.bytes(20);
-const Bytes32 = P.bytes(32);
+const BytesInf: P.CoderType<P.Bytes> = P.bytes(null); // Bytes will conflict with Bytes type
+const Bytes20: P.CoderType<P.Bytes> = P.bytes(20);
+const Bytes32: P.CoderType<P.Bytes> = P.bytes(32);
 // versionsRequiringExclusing = !versionsAllowsInclusion (as set)
 // {name: [tag, keyCoder, valueCoder, versionsRequiringInclusion, versionsRequiringExclusing, versionsAllowsInclusion, silentIgnore]}
 // SilentIgnore: we use some v2 fields for v1 representation too, so we just clean them before serialize
@@ -167,7 +178,12 @@ function PSBTKeyInfo(info: PSBTKeyMapInfo) {
 
 type PSBTKeyMap = Record<string, PSBTKeyMapInfo>;
 
-const PSBTUnknownKey = P.struct({ type: CompactSizeLen, key: P.bytes(null) });
+const PSBTUnknownKey: P.CoderType<
+  P.StructInput<{
+    type: number;
+    key: Uint8Array;
+  }>
+> = P.struct({ type: CompactSizeLen, key: P.bytes(null) });
 type PSBTUnknownFields = { unknown?: [P.UnwrapCoder<typeof PSBTUnknownKey>, Bytes][] };
 export type PSBTKeyMapKeys<T extends PSBTKeyMap> = {
   -readonly [K in keyof T]?: T[K][1] extends false
@@ -399,7 +415,7 @@ export function cleanPSBTFields<T extends PSBTKeyMap>(
   version: number,
   info: T,
   lst: PSBTKeyMapKeys<T>
-) {
+): PSBTKeyMapKeys<T> {
   const out: PSBTKeyMapKeys<T> = {};
   for (const _k in lst) {
     const k = _k as string & keyof PSBTKeyMapKeys<T>;
@@ -442,7 +458,8 @@ export function mergeKeyMap<T extends PSBTKeyMap>(
   psbtEnum: T,
   val: PSBTKeyMapKeys<T>,
   cur?: PSBTKeyMapKeys<T>,
-  allowedFields?: (keyof PSBTKeyMapKeys<T>)[]
+  allowedFields?: (keyof PSBTKeyMapKeys<T>)[],
+  allowUnknown?: boolean
 ): PSBTKeyMapKeys<T> {
   const res: PSBTKeyMapKeys<T> = { ...cur, ...val };
   // All arguments can be provided as hex
@@ -501,8 +518,13 @@ export function mergeKeyMap<T extends PSBTKeyMap>(
         throw new Error(`Cannot change signed field=${k}`);
     }
   }
-  // Remove unknown keys
-  for (const k in res) if (!psbtEnum[k]) delete res[k];
+  // Remove unknown keys except the "unknown" array if allowUnknown is true
+  for (const k in res) {
+    if (!psbtEnum[k]) {
+      if (allowUnknown && k === 'unknown') continue;
+      delete res[k];
+    }
+  }
   return res;
 }
 

package/src/script.ts

@@ -81,7 +81,7 @@ export function ScriptNum(bytesLimit = 6, forceMinimal = false): P.CoderType<big
   });
 }
 
-export function OpToNum(op: ScriptOP, bytesLimit = 4, forceMinimal = true) {
+export function OpToNum(op: ScriptOP, bytesLimit = 4, forceMinimal = true): number | undefined {
   if (typeof op === 'number') return op;
   if (isBytes(op)) {
     try {
@@ -197,13 +197,13 @@ export const CompactSize: P.CoderType<bigint> = P.wrap({
 });
 
 // Same thing, but in number instead of bigint. Checks for safe integer inside
-export const CompactSizeLen = P.apply(CompactSize, P.coders.numberBigint);
+export const CompactSizeLen: P.CoderType<number> = P.apply(CompactSize, P.coders.numberBigint);
 
 // ui8a of size <CompactSize>
-export const VarBytes = P.bytes(CompactSize);
+export const VarBytes: P.CoderType<Uint8Array> = P.bytes(CompactSize);
 
 // SegWit v0 stack of witness buffers
-export const RawWitness = P.array(CompactSizeLen, VarBytes);
+export const RawWitness: P.CoderType<Uint8Array[]> = P.array(CompactSizeLen, VarBytes);
 
 // Array of size <CompactSize>
 export const BTCArray = <T>(t: P.CoderType<T>): P.CoderType<T[]> => P.array(CompactSize, t);
@@ -235,7 +235,7 @@ function validateRawTx(tx: P.UnwrapCoder<typeof _RawTx>) {
     throw new Error('Segwit flag with empty witnesses array');
   return tx;
 }
-export const RawTx = P.validate(_RawTx, validateRawTx);
+export const RawTx: typeof _RawTx = P.validate(_RawTx, validateRawTx);
 // Pre-SegWit serialization format (for PSBTv0)
 export const RawOldTx = P.struct({
   version: P.I32LE,

package/src/transaction.ts

@@ -1,12 +1,19 @@
-import * as P from 'micro-packed';
 import { hex } from '@scure/base';
-import { Address, CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
+import * as P from 'micro-packed';
+import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
 import * as psbt from './psbt.js'; // circular
-import { CompactSizeLen, Script, VarBytes } from './script.js';
-import { RawOutput, RawTx, RawOldTx, RawWitness } from './script.js';
-import { NETWORK, Bytes, concatBytes, isBytes, equalBytes } from './utils.js';
+import {
+  CompactSizeLen,
+  RawOldTx,
+  RawOutput,
+  RawTx,
+  RawWitness,
+  Script,
+  VarBytes,
+} from './script.js';
 import * as u from './utils.js';
-import { getInputType, toVsize, normalizeInput, getPrevOut } from './utxo.js'; // circular
+import { type Bytes, NETWORK, concatBytes, equalBytes, isBytes } from './utils.js';
+import { getInputType, getPrevOut, normalizeInput, toVsize } from './utxo.js'; // circular
 
 const EMPTY32 = new Uint8Array(32);
 const EMPTY_OUTPUT: P.UnwrapCoder<typeof RawOutput> = {
@@ -30,10 +37,10 @@ export const PRECISION = 8;
 export const DEFAULT_VERSION = 2;
 export const DEFAULT_LOCKTIME = 0;
 export const DEFAULT_SEQUENCE = 4294967295;
-export const Decimal = P.coders.decimal(PRECISION);
+export const Decimal: P.Coder<bigint, string> = P.coders.decimal(PRECISION);
 
 // Same as value || def, but doesn't overwrites zero ('0', 0, 0n, etc)
-export const def = <T>(value: T | undefined, def: T) => (value === undefined ? def : value);
+export const def = <T>(value: T | undefined, def: T): T => (value === undefined ? def : value);
 
 export function cloneDeep<T>(obj: T): T {
   if (Array.isArray(obj)) return obj.map((i) => cloneDeep(i)) as unknown as T;
@@ -54,7 +61,7 @@ export function cloneDeep<T>(obj: T): T {
 
 // Mostly security features, hardened defaults;
 // but you still can parse other people tx with unspendable outputs and stuff if you want
-export type TxOpts = {
+export interface TxOpts {
   version?: number;
   lockTime?: number;
   PSBTVersion?: number;
@@ -77,7 +84,9 @@ export type TxOpts = {
   allowLegacyWitnessUtxo?: boolean;
   lowR?: boolean; // Use lowR signatures
   customScripts?: CustomScript[]; // UNSAFE: Custom payment scripts
-};
+  // Allow to add additional unknown keys/values to the "unknown" array member
+  allowUnknown?: boolean;
+}
 
 /**
  * Internal, exported only for backwards-compat. Use `SigHash` instead.
@@ -166,7 +175,7 @@ function unpackSighash(hashType: number) {
   };
 }
 
-function validateOpts(opts: TxOpts) {
+function validateOpts(opts: TxOpts): Readonly<TxOpts> {
   if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
     throw new Error(`Wrong object type for transaction options: ${opts}`);
 
@@ -182,7 +191,8 @@ function validateOpts(opts: TxOpts) {
   if (typeof _opts.allowUnknowOutput !== 'undefined')
     opts.allowUnknownOutputs = _opts.allowUnknowOutput;
   // 0 and -1 happens in tests
-  if (![-1, 0, 1, 2].includes(_opts.version)) throw new Error(`Unknown version: ${_opts.version}`);
+  if (![-1, 0, 1, 2, 3].includes(_opts.version))
+    throw new Error(`Unknown version: ${_opts.version}`);
   if (typeof _opts.lockTime !== 'number') throw new Error('Transaction lock time should be number');
   P.U32LE.encode(_opts.lockTime); // Additional range checks that lockTime
   // There is no PSBT v1, and any new version will probably have fields which we don't know how to parse, which
@@ -233,7 +243,7 @@ export class Transaction {
   }
 
   // Import
-  static fromRaw(raw: Bytes, opts: TxOpts = {}) {
+  static fromRaw(raw: Bytes, opts: TxOpts = {}): Transaction {
     const parsed = RawTx.decode(raw);
     const tx = new Transaction({ ...opts, version: parsed.version, lockTime: parsed.lockTime });
     for (const o of parsed.outputs) tx.addOutput(o);
@@ -246,7 +256,7 @@ export class Transaction {
     return tx;
   }
   // PSBT
-  static fromPSBT(psbt_: Bytes, opts: TxOpts = {}) {
+  static fromPSBT(psbt_: Bytes, opts: TxOpts = {}): Transaction {
     let parsed: P.UnwrapCoder<typeof psbt.RawPSBTV0>;
     try {
       parsed = psbt.RawPSBTV0.decode(psbt_);
@@ -281,7 +291,7 @@ export class Transaction {
     if (lockTime !== DEFAULT_LOCKTIME) tx.global.fallbackLocktime = lockTime;
     return tx;
   }
-  toPSBT(PSBTVersion = this.opts.PSBTVersion) {
+  toPSBT(PSBTVersion: number | undefined = this.opts.PSBTVersion): Uint8Array {
     if (PSBTVersion !== 0 && PSBTVersion !== 2)
       throw new Error(`Wrong PSBT version=${PSBTVersion}`);
     // if (PSBTVersion === 0 && this.inputs.length === 0) {
@@ -338,7 +348,7 @@ export class Transaction {
   }
 
   // BIP370 lockTime (https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#determining-lock-time)
-  get lockTime() {
+  get lockTime(): number {
     let height = DEFAULT_LOCKTIME;
     let heightCnt = 0;
     let time = DEFAULT_LOCKTIME;
@@ -358,7 +368,7 @@ export class Transaction {
     return this.global.fallbackLocktime || DEFAULT_LOCKTIME;
   }
 
-  get version() {
+  get version(): number {
     // Should be not possible
     if (this.global.txVersion === undefined) throw new Error('No global.txVersion');
     return this.global.txVersion;
@@ -419,7 +429,7 @@ export class Transaction {
     return { addInput, addOutput, inputs, outputs };
   }
 
-  get isFinal() {
+  get isFinal(): boolean {
     for (let idx = 0; idx < this.inputs.length; idx++)
       if (this.inputStatus(idx) !== 'finalized') return false;
     return true;
@@ -453,7 +463,7 @@ export class Transaction {
   get vsize(): number {
     return toVsize(this.weight);
   }
-  toBytes(withScriptSig = false, withWitness = false) {
+  toBytes(withScriptSig = false, withWitness = false): Uint8Array {
     return RawTx.encode({
       version: this.version,
       lockTime: this.lockTime,
@@ -469,15 +479,15 @@ export class Transaction {
   get unsignedTx(): Bytes {
     return this.toBytes(false, false);
   }
-  get hex() {
+  get hex(): string {
     return hex.encode(this.toBytes(true, this.hasWitnesses));
   }
 
-  get hash() {
+  get hash(): string {
     if (!this.isFinal) throw new Error('Transaction is not finalized');
     return hex.encode(u.sha256x2(this.toBytes(true)));
   }
-  get id() {
+  get id(): string {
     if (!this.isFinal) throw new Error('Transaction is not finalized');
     return hex.encode(u.sha256x2(this.toBytes(true)).reverse());
   }
@@ -486,11 +496,11 @@ export class Transaction {
     if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
       throw new Error(`Wrong input index=${idx}`);
   }
-  getInput(idx: number) {
+  getInput(idx: number): psbt.TransactionInput {
     this.checkInputIdx(idx);
     return cloneDeep(this.inputs[idx]);
   }
-  get inputsLength() {
+  get inputsLength(): number {
     return this.inputs.length;
   }
   // Modification
@@ -500,7 +510,7 @@ export class Transaction {
     this.inputs.push(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck));
     return this.inputs.length - 1;
   }
-  updateInput(idx: number, input: psbt.TransactionInputUpdate, _ignoreSignStatus = false) {
+  updateInput(idx: number, input: psbt.TransactionInputUpdate, _ignoreSignStatus = false): void {
     this.checkInputIdx(idx);
     let allowedFields = undefined;
     if (!_ignoreSignStatus) {
@@ -512,7 +522,8 @@ export class Transaction {
       input,
       this.inputs[idx],
       allowedFields,
-      this.opts.disableScriptCheck
+      this.opts.disableScriptCheck,
+      this.opts.allowUnknown
     );
   }
   // Output stuff
@@ -520,17 +531,17 @@ export class Transaction {
     if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.outputs.length)
       throw new Error(`Wrong output index=${idx}`);
   }
-  getOutput(idx: number) {
+  getOutput(idx: number): psbt.TransactionOutput {
     this.checkOutputIdx(idx);
     return cloneDeep(this.outputs[idx]);
   }
-  getOutputAddress(idx: number, network = NETWORK): string | undefined {
+  getOutputAddress(idx: number, network: u.BTC_NETWORK = NETWORK): string | undefined {
     const out = this.getOutput(idx);
     if (!out.script) return;
     return Address(network).encode(OutScript.decode(out.script));
   }
 
-  get outputsLength() {
+  get outputsLength(): number {
     return this.outputs.length;
   }
   private normalizeOutput(
@@ -548,7 +559,7 @@ export class Transaction {
     if (script === undefined) script = cur?.script;
     let res: psbt.PSBTKeyMapKeys<typeof psbt.PSBTOutput> = { ...cur, ...o, amount, script };
     if (res.amount === undefined) delete res.amount;
-    res = psbt.mergeKeyMap(psbt.PSBTOutput, res, cur, allowedFields);
+    res = psbt.mergeKeyMap(psbt.PSBTOutput, res, cur, allowedFields, this.opts.allowUnknown);
     psbt.PSBTOutputCoder.encode(res);
     if (
       res.script &&
@@ -568,7 +579,7 @@ export class Transaction {
     this.outputs.push(this.normalizeOutput(o));
     return this.outputs.length - 1;
   }
-  updateOutput(idx: number, output: psbt.TransactionOutputUpdate, _ignoreSignStatus = false) {
+  updateOutput(idx: number, output: psbt.TransactionOutputUpdate, _ignoreSignStatus = false): void {
     this.checkOutputIdx(idx);
     let allowedFields = undefined;
     if (!_ignoreSignStatus) {
@@ -578,7 +589,7 @@ export class Transaction {
     }
     this.outputs[idx] = this.normalizeOutput(output, this.outputs[idx], allowedFields);
   }
-  addOutputAddress(address: string, amount: bigint, network = NETWORK): number {
+  addOutputAddress(address: string, amount: bigint, network: u.BTC_NETWORK = NETWORK): number {
     return this.addOutput({ script: OutScript.encode(Address(network).decode(address)), amount });
   }
   // Utils
@@ -633,7 +644,12 @@ export class Transaction {
     });
     return u.sha256x2(tmpTx, P.I32LE.encode(hashType));
   }
-  preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint) {
+  preimageWitnessV0(
+    idx: number,
+    prevOutScript: Bytes,
+    hashType: number,
+    amount: bigint
+  ): Uint8Array {
     const { isAny, isNone, isSingle } = unpackSighash(hashType);
     let inputHash = EMPTY32;
     let sequenceHash = EMPTY32;
@@ -671,7 +687,7 @@ export class Transaction {
     leafScript?: Bytes,
     leafVer = 0xc0,
     annex?: Bytes
-  ) {
+  ): Uint8Array {
     if (!Array.isArray(amount) || this.inputs.length !== amount.length)
       throw new Error(`Invalid amounts array=${amount}`);
     if (!Array.isArray(prevOutScript) || this.inputs.length !== prevOutScript.length)
@@ -878,7 +894,7 @@ export class Transaction {
     return num;
   }
 
-  finalizeIdx(idx: number) {
+  finalizeIdx(idx: number): void {
     this.checkInputIdx(idx);
     if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
     const input = this.inputs[idx];
@@ -1027,10 +1043,10 @@ export class Transaction {
     if (finalScriptWitness) input.finalScriptWitness = finalScriptWitness;
     cleanFinalInput(input);
   }
-  finalize() {
+  finalize(): void {
     for (let i = 0; i < this.inputs.length; i++) this.finalizeIdx(i);
   }
-  extract() {
+  extract(): Uint8Array {
     if (!this.isFinal) throw new Error('Transaction has unfinalized inputs');
     if (!this.outputs.length) throw new Error('Transaction has no outputs');
     if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
@@ -1057,12 +1073,18 @@ export class Transaction {
       : P.EMPTY;
     if (!equalBytes(thisUnsigned, otherUnsigned))
       throw new Error(`Transaction/combine: different unsigned tx`);
-    this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global);
+    this.global = psbt.mergeKeyMap(
+      psbt.PSBTGlobal,
+      this.global,
+      other.global,
+      undefined,
+      this.opts.allowUnknown
+    );
     for (let i = 0; i < this.inputs.length; i++) this.updateInput(i, other.inputs[i], true);
     for (let i = 0; i < this.outputs.length; i++) this.updateOutput(i, other.outputs[i], true);
     return this;
   }
-  clone() {
+  clone(): Transaction {
     // deepClone probably faster, but this enforces that encoding is valid
     return Transaction.fromPSBT(this.toPSBT(this.opts.PSBTVersion), this.opts);
   }