{"version":3,"file":"transaction-m4QEenae.mjs","sources":["../node_modules/.pnpm/@scure+btc-signer@2.0.1/node_modules/@scure/btc-signer/psbt.js","../node_modules/.pnpm/@scure+btc-signer@2.0.1/node_modules/@scure/btc-signer/transaction.js"],"sourcesContent":["import { hex } from '@scure/base';\nimport * as P from 'micro-packed';\nimport { CompactSize, CompactSizeLen, RawOldTx, RawOutput, RawTx, RawWitness, VarBytes, } from \"./script.js\";\nimport { compareBytes, equalBytes, PubT, validatePubkey } from \"./utils.js\";\n// PSBT BIP174, BIP370, BIP371\n// Can be 33 or 64 bytes\nconst PubKeyECDSA = P.validate(P.bytes(null), (pub) => validatePubkey(pub, PubT.ecdsa));\nconst PubKeySchnorr = P.validate(P.bytes(32), (pub) => validatePubkey(pub, PubT.schnorr));\nconst SignatureSchnorr = P.validate(P.bytes(null), (sig) => {\n    if (sig.length !== 64 && sig.length !== 65)\n        throw new Error('Schnorr signature should be 64 or 65 bytes long');\n    return sig;\n});\nconst BIP32Der = P.struct({\n    fingerprint: P.U32BE,\n    path: P.array(null, P.U32LE),\n});\nconst TaprootBIP32Der = P.struct({\n    hashes: P.array(CompactSizeLen, P.bytes(32)),\n    der: BIP32Der,\n});\n// The 78 byte serialized extended public key as defined by BIP 32.\nconst GlobalXPUB = P.bytes(78);\nconst tapScriptSigKey = P.struct({ pubKey: PubKeySchnorr, leafHash: P.bytes(32) });\n// Complex structure for PSBT fields\n// <control byte with leaf version and parity bit> <internal key p> <C> <E> <AB>\nconst _TaprootControlBlock = P.struct({\n    version: P.U8, // With parity :(\n    internalKey: P.bytes(32),\n    merklePath: P.array(null, P.bytes(32)),\n});\nexport const TaprootControlBlock = P.validate(_TaprootControlBlock, (cb) => {\n    if (cb.merklePath.length > 128)\n        throw new Error('TaprootControlBlock: merklePath should be of length 0..128 (inclusive)');\n    return cb;\n});\n// {<8-bit uint depth> <8-bit uint leaf version> <compact size uint scriptlen> <bytes script>}*\nconst tapTree = P.array(null, P.struct({\n    depth: P.U8,\n    version: P.U8,\n    script: VarBytes,\n}));\nconst BytesInf = P.bytes(null); // Bytes will conflict with Bytes type\nconst Bytes20 = P.bytes(20);\nconst Bytes32 = P.bytes(32);\n// versionsRequiringExclusing = !versionsAllowsInclusion (as set)\n// {name: [tag, keyCoder, valueCoder, versionsRequiringInclusion, versionsRequiringExclusing, versionsAllowsInclusion, silentIgnore]}\n// SilentIgnore: we use some v2 fields for v1 representation too, so we just clean them before serialize\n// Tables from BIP-0174 (https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki)\n// prettier-ignore\nexport const PSBTGlobal = {\n    unsignedTx: [0x00, false, RawOldTx, [0], [0], false],\n    xpub: [0x01, GlobalXPUB, BIP32Der, [], [0, 2], false],\n    txVersion: [0x02, false, P.U32LE, [2], [2], false],\n    fallbackLocktime: [0x03, false, P.U32LE, [], [2], false],\n    inputCount: [0x04, false, CompactSizeLen, [2], [2], false],\n    outputCount: [0x05, false, CompactSizeLen, [2], [2], false],\n    txModifiable: [0x06, false, P.U8, [], [2], false], // TODO: bitfield\n    version: [0xfb, false, P.U32LE, [], [0, 2], false],\n    proprietary: [0xfc, BytesInf, BytesInf, [], [0, 2], false],\n};\n// prettier-ignore\nexport const PSBTInput = {\n    nonWitnessUtxo: [0x00, false, RawTx, [], [0, 2], false],\n    witnessUtxo: [0x01, false, RawOutput, [], [0, 2], false],\n    partialSig: [0x02, PubKeyECDSA, BytesInf, [], [0, 2], false],\n    sighashType: [0x03, false, P.U32LE, [], [0, 2], false],\n    redeemScript: [0x04, false, BytesInf, [], [0, 2], false],\n    witnessScript: [0x05, false, BytesInf, [], [0, 2], false],\n    bip32Derivation: [0x06, PubKeyECDSA, BIP32Der, [], [0, 2], false],\n    finalScriptSig: [0x07, false, BytesInf, [], [0, 2], false],\n    finalScriptWitness: [0x08, false, RawWitness, [], [0, 2], false],\n    porCommitment: [0x09, false, BytesInf, [], [0, 2], false],\n    ripemd160: [0x0a, Bytes20, BytesInf, [], [0, 2], false],\n    sha256: [0x0b, Bytes32, BytesInf, [], [0, 2], false],\n    hash160: [0x0c, Bytes20, BytesInf, [], [0, 2], false],\n    hash256: [0x0d, Bytes32, BytesInf, [], [0, 2], false],\n    txid: [0x0e, false, Bytes32, [2], [2], true],\n    index: [0x0f, false, P.U32LE, [2], [2], true],\n    sequence: [0x10, false, P.U32LE, [], [2], true],\n    requiredTimeLocktime: [0x11, false, P.U32LE, [], [2], false],\n    requiredHeightLocktime: [0x12, false, P.U32LE, [], [2], false],\n    tapKeySig: [0x13, false, SignatureSchnorr, [], [0, 2], false],\n    tapScriptSig: [0x14, tapScriptSigKey, SignatureSchnorr, [], [0, 2], false],\n    tapLeafScript: [0x15, TaprootControlBlock, BytesInf, [], [0, 2], false],\n    tapBip32Derivation: [0x16, Bytes32, TaprootBIP32Der, [], [0, 2], false],\n    tapInternalKey: [0x17, false, PubKeySchnorr, [], [0, 2], false],\n    tapMerkleRoot: [0x18, false, Bytes32, [], [0, 2], false],\n    proprietary: [0xfc, BytesInf, BytesInf, [], [0, 2], false],\n};\n// All other keys removed when finalizing\nexport const PSBTInputFinalKeys = [\n    'txid',\n    'sequence',\n    'index',\n    'witnessUtxo',\n    'nonWitnessUtxo',\n    'finalScriptSig',\n    'finalScriptWitness',\n    'unknown',\n];\n// Can be modified even on signed input\nexport const PSBTInputUnsignedKeys = [\n    'partialSig',\n    'finalScriptSig',\n    'finalScriptWitness',\n    'tapKeySig',\n    'tapScriptSig',\n];\n// prettier-ignore\nexport const PSBTOutput = {\n    redeemScript: [0x00, false, BytesInf, [], [0, 2], false],\n    witnessScript: [0x01, false, BytesInf, [], [0, 2], false],\n    bip32Derivation: [0x02, PubKeyECDSA, BIP32Der, [], [0, 2], false],\n    amount: [0x03, false, P.I64LE, [2], [2], true],\n    script: [0x04, false, BytesInf, [2], [2], true],\n    tapInternalKey: [0x05, false, PubKeySchnorr, [], [0, 2], false],\n    tapTree: [0x06, false, tapTree, [], [0, 2], false],\n    tapBip32Derivation: [0x07, PubKeySchnorr, TaprootBIP32Der, [], [0, 2], false],\n    proprietary: [0xfc, BytesInf, BytesInf, [], [0, 2], false],\n};\n// Can be modified even on signed input\nexport const PSBTOutputUnsignedKeys = [];\nconst PSBTKeyPair = P.array(P.NULL, P.struct({\n    //  <key> := <keylen> <keytype> <keydata> WHERE keylen = len(keytype)+len(keydata)\n    key: P.prefix(CompactSizeLen, P.struct({ type: CompactSizeLen, key: P.bytes(null) })),\n    //  <value> := <valuelen> <valuedata>\n    value: P.bytes(CompactSizeLen),\n}));\nfunction PSBTKeyInfo(info) {\n    const [type, kc, vc, reqInc, allowInc, silentIgnore] = info;\n    return { type, kc, vc, reqInc, allowInc, silentIgnore };\n}\nconst PSBTUnknownKey = P.struct({ type: CompactSizeLen, key: P.bytes(null) });\n// Key cannot be 'unknown', value coder cannot be array for elements with empty key\nfunction PSBTKeyMap(psbtEnum) {\n    // -> Record<type, [keyName, ...coders]>\n    const byType = {};\n    for (const k in psbtEnum) {\n        const [num, kc, vc] = psbtEnum[k];\n        byType[num] = [k, kc, vc];\n    }\n    return P.wrap({\n        encodeStream: (w, value) => {\n            let out = [];\n            // Because we use order of psbtEnum, keymap is sorted here\n            for (const name in psbtEnum) {\n                const val = value[name];\n                if (val === undefined)\n                    continue;\n                const [type, kc, vc] = psbtEnum[name];\n                if (!kc) {\n                    out.push({ key: { type, key: P.EMPTY }, value: vc.encode(val) });\n                }\n                else {\n                    // Low level interface, returns keys as is (with duplicates). Useful for debug\n                    const kv = val.map(([k, v]) => [\n                        kc.encode(k),\n                        vc.encode(v),\n                    ]);\n                    // sort by keys\n                    kv.sort((a, b) => compareBytes(a[0], b[0]));\n                    for (const [key, value] of kv)\n                        out.push({ key: { key, type }, value });\n                }\n            }\n            if (value.unknown) {\n                value.unknown.sort((a, b) => compareBytes(a[0].key, b[0].key));\n                for (const [k, v] of value.unknown)\n                    out.push({ key: k, value: v });\n            }\n            PSBTKeyPair.encodeStream(w, out);\n        },\n        decodeStream: (r) => {\n            const raw = PSBTKeyPair.decodeStream(r);\n            const out = {};\n            const noKey = {};\n            for (const elm of raw) {\n                let name = 'unknown';\n                let key = elm.key.key;\n                let value = elm.value;\n                if (byType[elm.key.type]) {\n                    const [_name, kc, vc] = byType[elm.key.type];\n                    name = _name;\n                    if (!kc && key.length) {\n                        throw new Error(`PSBT: Non-empty key for ${name} (key=${hex.encode(key)} value=${hex.encode(value)}`);\n                    }\n                    key = kc ? kc.decode(key) : undefined;\n                    value = vc.decode(value);\n                    if (!kc) {\n                        if (out[name])\n                            throw new Error(`PSBT: Same keys: ${name} (key=${key} value=${value})`);\n                        out[name] = value;\n                        noKey[name] = true;\n                        continue;\n                    }\n                }\n                else {\n                    // For unknown: add key type inside key\n                    key = { type: elm.key.type, key: elm.key.key };\n                }\n                // Only keyed elements at this point\n                if (noKey[name])\n                    throw new Error(`PSBT: Key type with empty key and no key=${name} val=${value}`);\n                if (!out[name])\n                    out[name] = [];\n                out[name].push([key, value]);\n            }\n            return out;\n        },\n    });\n}\nexport const PSBTInputCoder = P.validate(PSBTKeyMap(PSBTInput), (i) => {\n    if (i.finalScriptWitness && !i.finalScriptWitness.length)\n        throw new Error('validateInput: empty finalScriptWitness');\n    //if (i.finalScriptSig && !i.finalScriptSig.length) throw new Error('validateInput: empty finalScriptSig');\n    if (i.partialSig && !i.partialSig.length)\n        throw new Error('Empty partialSig');\n    if (i.partialSig)\n        for (const [k] of i.partialSig)\n            validatePubkey(k, PubT.ecdsa);\n    if (i.bip32Derivation)\n        for (const [k] of i.bip32Derivation)\n            validatePubkey(k, PubT.ecdsa);\n    // Locktime = unsigned little endian integer greater than or equal to 500000000 representing\n    if (i.requiredTimeLocktime !== undefined && i.requiredTimeLocktime < 500000000)\n        throw new Error(`validateInput: wrong timeLocktime=${i.requiredTimeLocktime}`);\n    // unsigned little endian integer greater than 0 and less than 500000000\n    if (i.requiredHeightLocktime !== undefined &&\n        (i.requiredHeightLocktime <= 0 || i.requiredHeightLocktime >= 500000000))\n        throw new Error(`validateInput: wrong heighLocktime=${i.requiredHeightLocktime}`);\n    if (i.tapLeafScript) {\n        // tap leaf version appears here twice: in control block and at the end of script\n        for (const [k, v] of i.tapLeafScript) {\n            if ((k.version & 0b1111_1110) !== v[v.length - 1])\n                throw new Error('validateInput: tapLeafScript version mimatch');\n            if (v[v.length - 1] & 1)\n                throw new Error('validateInput: tapLeafScript version has parity bit!');\n        }\n    }\n    return i;\n});\nexport const PSBTOutputCoder = P.validate(PSBTKeyMap(PSBTOutput), (o) => {\n    if (o.bip32Derivation)\n        for (const [k] of o.bip32Derivation)\n            validatePubkey(k, PubT.ecdsa);\n    return o;\n});\nconst PSBTGlobalCoder = P.validate(PSBTKeyMap(PSBTGlobal), (g) => {\n    const version = g.version || 0;\n    if (version === 0) {\n        if (!g.unsignedTx)\n            throw new Error('PSBTv0: missing unsignedTx');\n        for (const inp of g.unsignedTx.inputs)\n            if (inp.finalScriptSig && inp.finalScriptSig.length)\n                throw new Error('PSBTv0: input scriptSig found in unsignedTx');\n    }\n    return g;\n});\nexport const _RawPSBTV0 = P.struct({\n    magic: P.magic(P.string(new Uint8Array([0xff])), 'psbt'),\n    global: PSBTGlobalCoder,\n    inputs: P.array('global/unsignedTx/inputs/length', PSBTInputCoder),\n    outputs: P.array(null, PSBTOutputCoder),\n});\nexport const _RawPSBTV2 = P.struct({\n    magic: P.magic(P.string(new Uint8Array([0xff])), 'psbt'),\n    global: PSBTGlobalCoder,\n    inputs: P.array('global/inputCount', PSBTInputCoder),\n    outputs: P.array('global/outputCount', PSBTOutputCoder),\n});\nexport const _DebugPSBT = P.struct({\n    magic: P.magic(P.string(new Uint8Array([0xff])), 'psbt'),\n    items: P.array(null, P.apply(P.array(P.NULL, P.tuple([P.hex(CompactSizeLen), P.bytes(CompactSize)])), P.coders.dict())),\n});\nfunction validatePSBTFields(version, info, lst) {\n    for (const k in lst) {\n        if (k === 'unknown')\n            continue;\n        if (!info[k])\n            continue;\n        const { allowInc } = PSBTKeyInfo(info[k]);\n        if (!allowInc.includes(version))\n            throw new Error(`PSBTv${version}: field ${k} is not allowed`);\n    }\n    for (const k in info) {\n        const { reqInc } = PSBTKeyInfo(info[k]);\n        if (reqInc.includes(version) && lst[k] === undefined)\n            throw new Error(`PSBTv${version}: missing required field ${k}`);\n    }\n}\nexport function cleanPSBTFields(version, info, lst) {\n    const out = {};\n    for (const _k in lst) {\n        const k = _k;\n        if (k !== 'unknown') {\n            if (!info[k])\n                continue;\n            const { allowInc, silentIgnore } = PSBTKeyInfo(info[k]);\n            if (!allowInc.includes(version)) {\n                if (silentIgnore)\n                    continue;\n                throw new Error(`Failed to serialize in PSBTv${version}: ${k} but versions allows inclusion=${allowInc}`);\n            }\n        }\n        out[k] = lst[k];\n    }\n    return out;\n}\nfunction validatePSBT(tx) {\n    const version = (tx && tx.global && tx.global.version) || 0;\n    validatePSBTFields(version, PSBTGlobal, tx.global);\n    for (const i of tx.inputs)\n        validatePSBTFields(version, PSBTInput, i);\n    for (const o of tx.outputs)\n        validatePSBTFields(version, PSBTOutput, o);\n    // We allow only one empty element at the end of map (compat with bitcoinjs-lib bug)\n    const inputCount = !version ? tx.global.unsignedTx.inputs.length : tx.global.inputCount;\n    if (tx.inputs.length < inputCount)\n        throw new Error('Not enough inputs');\n    const inputsLeft = tx.inputs.slice(inputCount);\n    if (inputsLeft.length > 1 || (inputsLeft.length && Object.keys(inputsLeft[0]).length))\n        throw new Error(`Unexpected inputs left in tx=${inputsLeft}`);\n    // Same for inputs\n    const outputCount = !version ? tx.global.unsignedTx.outputs.length : tx.global.outputCount;\n    if (tx.outputs.length < outputCount)\n        throw new Error('Not outputs inputs');\n    const outputsLeft = tx.outputs.slice(outputCount);\n    if (outputsLeft.length > 1 || (outputsLeft.length && Object.keys(outputsLeft[0]).length))\n        throw new Error(`Unexpected outputs left in tx=${outputsLeft}`);\n    return tx;\n}\nexport function mergeKeyMap(psbtEnum, val, cur, allowedFields, allowUnknown) {\n    const res = { ...cur, ...val };\n    // All arguments can be provided as hex\n    for (const k in psbtEnum) {\n        const key = k;\n        const [_, kC, vC] = psbtEnum[key];\n        const cannotChange = allowedFields && !allowedFields.includes(k);\n        if (val[k] === undefined && k in val) {\n            if (cannotChange)\n                throw new Error(`Cannot remove signed field=${k}`);\n            delete res[k];\n        }\n        else if (kC) {\n            const oldKV = (cur && cur[k] ? cur[k] : []);\n            let newKV = val[key];\n            if (newKV) {\n                if (!Array.isArray(newKV))\n                    throw new Error(`keyMap(${k}): KV pairs should be [k, v][]`);\n                // Decode hex in k-v\n                newKV = newKV.map((val) => {\n                    if (val.length !== 2)\n                        throw new Error(`keyMap(${k}): KV pairs should be [k, v][]`);\n                    return [\n                        typeof val[0] === 'string' ? kC.decode(hex.decode(val[0])) : val[0],\n                        typeof val[1] === 'string' ? vC.decode(hex.decode(val[1])) : val[1],\n                    ];\n                });\n                const map = {};\n                const add = (kStr, k, v) => {\n                    if (map[kStr] === undefined) {\n                        map[kStr] = [k, v];\n                        return;\n                    }\n                    const oldVal = hex.encode(vC.encode(map[kStr][1]));\n                    const newVal = hex.encode(vC.encode(v));\n                    if (oldVal !== newVal)\n                        throw new Error(`keyMap(${key}): same key=${kStr} oldVal=${oldVal} newVal=${newVal}`);\n                };\n                for (const [k, v] of oldKV) {\n                    const kStr = hex.encode(kC.encode(k));\n                    add(kStr, k, v);\n                }\n                for (const [k, v] of newKV) {\n                    const kStr = hex.encode(kC.encode(k));\n                    // undefined removes previous value\n                    if (v === undefined) {\n                        if (cannotChange)\n                            throw new Error(`Cannot remove signed field=${key}/${k}`);\n                        delete map[kStr];\n                    }\n                    else\n                        add(kStr, k, v);\n                }\n                res[key] = Object.values(map);\n            }\n        }\n        else if (typeof res[k] === 'string') {\n            res[k] = vC.decode(hex.decode(res[k]));\n        }\n        else if (cannotChange && k in val && cur && cur[k] !== undefined) {\n            if (!equalBytes(vC.encode(val[k]), vC.encode(cur[k])))\n                throw new Error(`Cannot change signed field=${k}`);\n        }\n    }\n    // Remove unknown keys except the \"unknown\" array if allowUnknown is true\n    for (const k in res) {\n        if (!psbtEnum[k]) {\n            if (allowUnknown && k === 'unknown')\n                continue;\n            delete res[k];\n        }\n    }\n    return res;\n}\nexport const RawPSBTV0 = P.validate(_RawPSBTV0, validatePSBT);\nexport const RawPSBTV2 = P.validate(_RawPSBTV2, validatePSBT);\n//# sourceMappingURL=psbt.js.map","import { hex } from '@scure/base';\nimport * as P from 'micro-packed';\nimport { Address, OutScript, checkScript, tapLeafHash } from \"./payment.js\";\nimport * as psbt from \"./psbt.js\";\nimport { CompactSizeLen, RawOldTx, RawOutput, RawTx, RawWitness, Script, VarBytes, } from \"./script.js\";\nimport * as u from \"./utils.js\";\nimport { NETWORK, concatBytes, equalBytes, isBytes } from \"./utils.js\";\nconst EMPTY32 = new Uint8Array(32);\nconst EMPTY_OUTPUT = {\n    amount: 0xffffffffffffffffn,\n    script: P.EMPTY,\n};\nexport const toVsize = (weight) => Math.ceil(weight / 4);\nexport const PRECISION = 8;\nexport const DEFAULT_VERSION = 2;\nexport const DEFAULT_LOCKTIME = 0;\nexport const DEFAULT_SEQUENCE = 4294967295;\nexport const Decimal = P.coders.decimal(PRECISION);\n// Same as value || def, but doesn't overwrites zero ('0', 0, 0n, etc)\nexport const def = (value, def) => (value === undefined ? def : value);\nexport function cloneDeep(obj) {\n    if (Array.isArray(obj))\n        return obj.map((i) => cloneDeep(i));\n    // slice of nodejs Buffer doesn't copy\n    else if (isBytes(obj))\n        return Uint8Array.from(obj);\n    // immutable\n    else if (['number', 'bigint', 'boolean', 'string', 'undefined'].includes(typeof obj))\n        return obj;\n    // null is object\n    else if (obj === null)\n        return obj;\n    // should be last, so it won't catch other types\n    else if (typeof obj === 'object') {\n        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, cloneDeep(v)]));\n    }\n    throw new Error(`cloneDeep: unknown type=${obj} (${typeof obj})`);\n}\n/**\n * Internal, exported only for backwards-compat. Use `SigHash` instead.\n * @deprecated\n */\nexport const SignatureHash = {\n    DEFAULT: 0,\n    ALL: 1,\n    NONE: 2,\n    SINGLE: 3,\n    ANYONECANPAY: 0x80,\n};\nexport const SigHash = {\n    DEFAULT: SignatureHash.DEFAULT,\n    ALL: SignatureHash.ALL,\n    NONE: SignatureHash.NONE,\n    SINGLE: SignatureHash.SINGLE,\n    DEFAULT_ANYONECANPAY: SignatureHash.DEFAULT | SignatureHash.ANYONECANPAY,\n    ALL_ANYONECANPAY: SignatureHash.ALL | SignatureHash.ANYONECANPAY,\n    NONE_ANYONECANPAY: SignatureHash.NONE | SignatureHash.ANYONECANPAY,\n    SINGLE_ANYONECANPAY: SignatureHash.SINGLE | SignatureHash.ANYONECANPAY,\n};\nexport const SigHashNames = u.reverseObject(SigHash);\nfunction getTaprootKeys(privKey, pubKey, internalKey, merkleRoot = P.EMPTY) {\n    if (equalBytes(internalKey, pubKey)) {\n        privKey = u.taprootTweakPrivKey(privKey, merkleRoot);\n        pubKey = u.pubSchnorr(privKey);\n    }\n    return { privKey, pubKey };\n}\n// Force check amount/script\nfunction outputBeforeSign(i) {\n    if (i.script === undefined || i.amount === undefined)\n        throw new Error('Transaction/output: script and amount required');\n    return { script: i.script, amount: i.amount };\n}\n// Force check index/txid/sequence\nexport function inputBeforeSign(i) {\n    if (i.txid === undefined || i.index === undefined)\n        throw new Error('Transaction/input: txid and index required');\n    return {\n        txid: i.txid,\n        index: i.index,\n        sequence: def(i.sequence, DEFAULT_SEQUENCE),\n        finalScriptSig: def(i.finalScriptSig, P.EMPTY),\n    };\n}\nfunction cleanFinalInput(i) {\n    for (const _k in i) {\n        const k = _k;\n        if (!psbt.PSBTInputFinalKeys.includes(k))\n            delete i[k];\n    }\n}\n// (TxHash, Idx)\nconst TxHashIdx = P.struct({ txid: P.bytes(32, true), index: P.U32LE });\nfunction validateSigHash(s) {\n    if (typeof s !== 'number' || typeof SigHashNames[s] !== 'string')\n        throw new Error(`Invalid SigHash=${s}`);\n    return s;\n}\nfunction unpackSighash(hashType) {\n    const masked = hashType & 0b0011111;\n    return {\n        isAny: !!(hashType & SignatureHash.ANYONECANPAY),\n        isNone: masked === SignatureHash.NONE,\n        isSingle: masked === SignatureHash.SINGLE,\n    };\n}\nfunction validateOpts(opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error(`Wrong object type for transaction options: ${opts}`);\n    const _opts = {\n        ...opts,\n        // Defaults\n        version: def(opts.version, DEFAULT_VERSION),\n        lockTime: def(opts.lockTime, 0),\n        PSBTVersion: def(opts.PSBTVersion, 0),\n    };\n    if (typeof _opts.allowUnknowInput !== 'undefined')\n        opts.allowUnknownInputs = _opts.allowUnknowInput;\n    if (typeof _opts.allowUnknowOutput !== 'undefined')\n        opts.allowUnknownOutputs = _opts.allowUnknowOutput;\n    if (typeof _opts.lockTime !== 'number')\n        throw new Error('Transaction lock time should be number');\n    P.U32LE.encode(_opts.lockTime); // Additional range checks that lockTime\n    // There is no PSBT v1, and any new version will probably have fields which we don't know how to parse, which\n    // can lead to constructing broken transactions\n    if (_opts.PSBTVersion !== 0 && _opts.PSBTVersion !== 2)\n        throw new Error(`Unknown PSBT version ${_opts.PSBTVersion}`);\n    // Flags\n    for (const k of [\n        'allowUnknownVersion',\n        'allowUnknownOutputs',\n        'allowUnknownInputs',\n        'disableScriptCheck',\n        'bip174jsCompat',\n        'allowLegacyWitnessUtxo',\n        'lowR',\n    ]) {\n        const v = _opts[k];\n        if (v === undefined)\n            continue; // optional\n        if (typeof v !== 'boolean')\n            throw new Error(`Transation options wrong type: ${k}=${v} (${typeof v})`);\n    }\n    // 0 and -1 happens in tests\n    if (_opts.allowUnknownVersion\n        ? typeof _opts.version === 'number'\n        : ![-1, 0, 1, 2, 3].includes(_opts.version))\n        throw new Error(`Unknown version: ${_opts.version}`);\n    if (_opts.customScripts !== undefined) {\n        const cs = _opts.customScripts;\n        if (!Array.isArray(cs)) {\n            throw new Error(`wrong custom scripts type (expected array): customScripts=${cs} (${typeof cs})`);\n        }\n        for (const s of cs) {\n            if (typeof s.encode !== 'function' || typeof s.decode !== 'function')\n                throw new Error(`wrong script=${s} (${typeof s})`);\n            if (s.finalizeTaproot !== undefined && typeof s.finalizeTaproot !== 'function')\n                throw new Error(`wrong script=${s} (${typeof s})`);\n        }\n    }\n    return Object.freeze(_opts);\n}\n// NOTE: we cannot do this inside PSBTInput coder, because there is no index/txid at this point!\nfunction validateInput(i) {\n    if (i.nonWitnessUtxo && i.index !== undefined) {\n        const last = i.nonWitnessUtxo.outputs.length - 1;\n        if (i.index > last)\n            throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);\n        const prevOut = i.nonWitnessUtxo.outputs[i.index];\n        if (i.witnessUtxo &&\n            (!equalBytes(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))\n            throw new Error('validateInput: witnessUtxo different from nonWitnessUtxo');\n        if (i.txid) {\n            const outputs = i.nonWitnessUtxo.outputs;\n            if (outputs.length - 1 < i.index)\n                throw new Error('nonWitnessUtxo: incorect output index');\n            // At this point, we are using previous tx output to create new input.\n            // Script safety checks are unnecessary:\n            // - User has no control over previous tx. If somebody send money in same tx\n            //   as unspendable output, we still want user able to spend money\n            // - We still want some checks to notify user about possible errors early\n            //   in case user wants to use wrong input by mistake\n            // - Worst case: tx will be rejected by nodes. Still better than disallowing user\n            //   to spend real input, no matter how broken it looks\n            const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo), {\n                allowUnknownOutputs: true,\n                disableScriptCheck: true,\n                allowUnknownInputs: true,\n            });\n            const txid = hex.encode(i.txid);\n            // PSBTv2 vectors have non-final tx in inputs\n            if (tx.isFinal && tx.id !== txid)\n                throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);\n        }\n    }\n    return i;\n}\n// Normalizes input\nexport function getPrevOut(input) {\n    if (input.nonWitnessUtxo) {\n        if (input.index === undefined)\n            throw new Error('Unknown input index');\n        return input.nonWitnessUtxo.outputs[input.index];\n    }\n    else if (input.witnessUtxo)\n        return input.witnessUtxo;\n    else\n        throw new Error('Cannot find previous output info');\n}\nexport function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allowUnknown = false) {\n    let { nonWitnessUtxo, txid } = i;\n    // String support for common fields. We usually prefer Uint8Array to avoid errors\n    // like hex looking string accidentally passed, however, in case of nonWitnessUtxo\n    // it is better to expect string, since constructing this complex object will be\n    // difficult for user\n    if (typeof nonWitnessUtxo === 'string')\n        nonWitnessUtxo = hex.decode(nonWitnessUtxo);\n    if (isBytes(nonWitnessUtxo))\n        nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);\n    if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)\n        nonWitnessUtxo = cur?.nonWitnessUtxo;\n    if (typeof txid === 'string')\n        txid = hex.decode(txid);\n    // TODO: if we have nonWitnessUtxo, we can extract txId from here\n    if (txid === undefined)\n        txid = cur?.txid;\n    let res = { ...cur, ...i, nonWitnessUtxo, txid };\n    if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined)\n        delete res.nonWitnessUtxo;\n    if (res.sequence === undefined)\n        res.sequence = DEFAULT_SEQUENCE;\n    if (res.tapMerkleRoot === null)\n        delete res.tapMerkleRoot;\n    res = psbt.mergeKeyMap(psbt.PSBTInput, res, cur, allowedFields, allowUnknown);\n    psbt.PSBTInputCoder.encode(res); // Validates that everything is correct at this point\n    let prevOut;\n    if (res.nonWitnessUtxo && res.index !== undefined)\n        prevOut = res.nonWitnessUtxo.outputs[res.index];\n    else if (res.witnessUtxo)\n        prevOut = res.witnessUtxo;\n    if (prevOut && !disableScriptCheck)\n        checkScript(prevOut && prevOut.script, res.redeemScript, res.witnessScript);\n    return res;\n}\nexport function getInputType(input, allowLegacyWitnessUtxo = false) {\n    let txType = 'legacy';\n    let defaultSighash = SignatureHash.ALL;\n    const prevOut = getPrevOut(input);\n    const first = OutScript.decode(prevOut.script);\n    let type = first.type;\n    let cur = first;\n    const stack = [first];\n    if (first.type === 'tr') {\n        defaultSighash = SignatureHash.DEFAULT;\n        return {\n            txType: 'taproot',\n            type: 'tr',\n            last: first,\n            lastScript: prevOut.script,\n            defaultSighash,\n            sighash: input.sighashType || defaultSighash,\n        };\n    }\n    else {\n        if (first.type === 'wpkh' || first.type === 'wsh')\n            txType = 'segwit';\n        if (first.type === 'sh') {\n            if (!input.redeemScript)\n                throw new Error('inputType: sh without redeemScript');\n            let child = OutScript.decode(input.redeemScript);\n            if (child.type === 'wpkh' || child.type === 'wsh')\n                txType = 'segwit';\n            stack.push(child);\n            cur = child;\n            type += `-${child.type}`;\n        }\n        // wsh can be inside sh\n        if (cur.type === 'wsh') {\n            if (!input.witnessScript)\n                throw new Error('inputType: wsh without witnessScript');\n            let child = OutScript.decode(input.witnessScript);\n            if (child.type === 'wsh')\n                txType = 'segwit';\n            stack.push(child);\n            cur = child;\n            type += `-${child.type}`;\n        }\n        const last = stack[stack.length - 1];\n        if (last.type === 'sh' || last.type === 'wsh')\n            throw new Error('inputType: sh/wsh cannot be terminal type');\n        const lastScript = OutScript.encode(last);\n        const res = {\n            type,\n            txType,\n            last,\n            lastScript,\n            defaultSighash,\n            sighash: input.sighashType || defaultSighash,\n        };\n        if (txType === 'legacy' && !allowLegacyWitnessUtxo && !input.nonWitnessUtxo) {\n            throw new Error(`Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure`);\n        }\n        return res;\n    }\n}\nexport class Transaction {\n    global = {};\n    inputs = []; // use getInput()\n    outputs = []; // use getOutput()\n    opts;\n    constructor(opts = {}) {\n        const _opts = (this.opts = validateOpts(opts));\n        // Merge with global structure of PSBTv2\n        if (_opts.lockTime !== DEFAULT_LOCKTIME)\n            this.global.fallbackLocktime = _opts.lockTime;\n        this.global.txVersion = _opts.version;\n    }\n    // Import\n    static fromRaw(raw, opts = {}) {\n        const parsed = RawTx.decode(raw);\n        const tx = new Transaction({ ...opts, version: parsed.version, lockTime: parsed.lockTime });\n        for (const o of parsed.outputs)\n            tx.addOutput(o);\n        tx.outputs = parsed.outputs;\n        tx.inputs = parsed.inputs;\n        if (parsed.witnesses) {\n            for (let i = 0; i < parsed.witnesses.length; i++)\n                tx.inputs[i].finalScriptWitness = parsed.witnesses[i];\n        }\n        return tx;\n    }\n    // PSBT\n    static fromPSBT(psbt_, opts = {}) {\n        let parsed;\n        try {\n            parsed = psbt.RawPSBTV0.decode(psbt_);\n        }\n        catch (e0) {\n            try {\n                parsed = psbt.RawPSBTV2.decode(psbt_);\n            }\n            catch (e2) {\n                // Throw error for v0 parsing, since it popular, otherwise it would be shadowed by v2 error\n                throw e0;\n            }\n        }\n        const PSBTVersion = parsed.global.version || 0;\n        if (PSBTVersion !== 0 && PSBTVersion !== 2)\n            throw new Error(`Wrong PSBT version=${PSBTVersion}`);\n        const unsigned = parsed.global.unsignedTx;\n        const version = PSBTVersion === 0 ? unsigned?.version : parsed.global.txVersion;\n        const lockTime = PSBTVersion === 0 ? unsigned?.lockTime : parsed.global.fallbackLocktime;\n        const tx = new Transaction({ ...opts, version, lockTime, PSBTVersion });\n        // We need slice here, because otherwise\n        const inputCount = PSBTVersion === 0 ? unsigned?.inputs.length : parsed.global.inputCount;\n        tx.inputs = parsed.inputs.slice(0, inputCount).map((i, j) => validateInput({\n            finalScriptSig: P.EMPTY,\n            ...parsed.global.unsignedTx?.inputs[j],\n            ...i,\n        }));\n        const outputCount = PSBTVersion === 0 ? unsigned?.outputs.length : parsed.global.outputCount;\n        tx.outputs = parsed.outputs.slice(0, outputCount).map((i, j) => ({\n            ...i,\n            ...parsed.global.unsignedTx?.outputs[j],\n        }));\n        tx.global = { ...parsed.global, txVersion: version }; // just in case proprietary/unknown fields\n        if (lockTime !== DEFAULT_LOCKTIME)\n            tx.global.fallbackLocktime = lockTime;\n        return tx;\n    }\n    toPSBT(PSBTVersion = this.opts.PSBTVersion) {\n        if (PSBTVersion !== 0 && PSBTVersion !== 2)\n            throw new Error(`Wrong PSBT version=${PSBTVersion}`);\n        // if (PSBTVersion === 0 && this.inputs.length === 0) {\n        //   throw new Error(\n        //     'PSBT version=0 export for transaction without inputs disabled, please use version=2. Please check `toPSBT` method for explanation.'\n        //   );\n        // }\n        const inputs = this.inputs.map((i) => validateInput(psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i)));\n        for (const inp of inputs) {\n            // Don't serialize empty fields\n            if (inp.partialSig && !inp.partialSig.length)\n                delete inp.partialSig;\n            if (inp.finalScriptSig && !inp.finalScriptSig.length)\n                delete inp.finalScriptSig;\n            if (inp.finalScriptWitness && !inp.finalScriptWitness.length)\n                delete inp.finalScriptWitness;\n        }\n        const outputs = this.outputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTOutput, i));\n        const global = { ...this.global };\n        if (PSBTVersion === 0) {\n            /*\n            - Bitcoin raw transaction expects to have at least 1 input because it uses case with zero inputs as marker for SegWit\n            - this means we cannot serialize raw tx with zero inputs since it will be parsed as SegWit tx\n            - Parsing of PSBTv0 depends on unsignedTx (it looks for input count here)\n            - BIP-174 requires old serialization format (without witnesses) inside global, which solves this\n            */\n            global.unsignedTx = RawOldTx.decode(RawOldTx.encode({\n                version: this.version,\n                lockTime: this.lockTime,\n                inputs: this.inputs.map(inputBeforeSign).map((i) => ({\n                    ...i,\n                    finalScriptSig: P.EMPTY,\n                })),\n                outputs: this.outputs.map(outputBeforeSign),\n            }));\n            delete global.fallbackLocktime;\n            delete global.txVersion;\n        }\n        else {\n            global.version = PSBTVersion;\n            global.txVersion = this.version;\n            global.inputCount = this.inputs.length;\n            global.outputCount = this.outputs.length;\n            if (global.fallbackLocktime && global.fallbackLocktime === DEFAULT_LOCKTIME)\n                delete global.fallbackLocktime;\n        }\n        if (this.opts.bip174jsCompat) {\n            if (!inputs.length)\n                inputs.push({});\n            if (!outputs.length)\n                outputs.push({});\n        }\n        return (PSBTVersion === 0 ? psbt.RawPSBTV0 : psbt.RawPSBTV2).encode({\n            global,\n            inputs,\n            outputs,\n        });\n    }\n    // BIP370 lockTime (https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#determining-lock-time)\n    get lockTime() {\n        let height = DEFAULT_LOCKTIME;\n        let heightCnt = 0;\n        let time = DEFAULT_LOCKTIME;\n        let timeCnt = 0;\n        for (const i of this.inputs) {\n            if (i.requiredHeightLocktime) {\n                height = Math.max(height, i.requiredHeightLocktime);\n                heightCnt++;\n            }\n            if (i.requiredTimeLocktime) {\n                time = Math.max(time, i.requiredTimeLocktime);\n                timeCnt++;\n            }\n        }\n        if (heightCnt && heightCnt >= timeCnt)\n            return height;\n        if (time !== DEFAULT_LOCKTIME)\n            return time;\n        return this.global.fallbackLocktime || DEFAULT_LOCKTIME;\n    }\n    get version() {\n        // Should be not possible\n        if (this.global.txVersion === undefined)\n            throw new Error('No global.txVersion');\n        return this.global.txVersion;\n    }\n    inputStatus(idx) {\n        this.checkInputIdx(idx);\n        const input = this.inputs[idx];\n        // Finalized\n        if (input.finalScriptSig && input.finalScriptSig.length)\n            return 'finalized';\n        if (input.finalScriptWitness && input.finalScriptWitness.length)\n            return 'finalized';\n        // Signed taproot\n        if (input.tapKeySig)\n            return 'signed';\n        if (input.tapScriptSig && input.tapScriptSig.length)\n            return 'signed';\n        // Signed\n        if (input.partialSig && input.partialSig.length)\n            return 'signed';\n        return 'unsigned';\n    }\n    // Cannot replace unpackSighash, tests rely on very generic implemenetation with signing inputs outside of range\n    // We will lose some vectors -> smaller test coverage of preimages (very important!)\n    inputSighash(idx) {\n        this.checkInputIdx(idx);\n        const inputSighash = this.inputs[idx].sighashType;\n        const sighash = inputSighash === undefined ? SignatureHash.DEFAULT : inputSighash;\n        // ALL or DEFAULT -- everything signed\n        // NONE           -- all inputs + no outputs\n        // SINGLE         -- all inputs + output with same index\n        // ALL + ANYONE   -- specific input + all outputs\n        // NONE + ANYONE  -- specific input + no outputs\n        // SINGLE         -- specific inputs + output with same index\n        const sigOutputs = sighash === SignatureHash.DEFAULT ? SignatureHash.ALL : sighash & 0b11;\n        const sigInputs = sighash & SignatureHash.ANYONECANPAY;\n        return { sigInputs, sigOutputs };\n    }\n    // Very nice for debug purposes, but slow. If there is too much inputs/outputs to add, will be quadratic.\n    // Some cache will be nice, but there chance to have bugs with cache invalidation\n    signStatus() {\n        // if addInput or addOutput is not possible, then all inputs or outputs are signed\n        let addInput = true, addOutput = true;\n        let inputs = [], outputs = [];\n        for (let idx = 0; idx < this.inputs.length; idx++) {\n            const status = this.inputStatus(idx);\n            // Unsigned input doesn't affect anything\n            if (status === 'unsigned')\n                continue;\n            const { sigInputs, sigOutputs } = this.inputSighash(idx);\n            // Input type\n            if (sigInputs === SignatureHash.ANYONECANPAY)\n                inputs.push(idx);\n            else\n                addInput = false;\n            // Output type\n            if (sigOutputs === SignatureHash.ALL)\n                addOutput = false;\n            else if (sigOutputs === SignatureHash.SINGLE)\n                outputs.push(idx);\n            else if (sigOutputs === SignatureHash.NONE) {\n                // Doesn't affect any outputs at all\n            }\n            else\n                throw new Error(`Wrong signature hash output type: ${sigOutputs}`);\n        }\n        return { addInput, addOutput, inputs, outputs };\n    }\n    get isFinal() {\n        for (let idx = 0; idx < this.inputs.length; idx++)\n            if (this.inputStatus(idx) !== 'finalized')\n                return false;\n        return true;\n    }\n    // Info utils\n    get hasWitnesses() {\n        let out = false;\n        for (const i of this.inputs)\n            if (i.finalScriptWitness && i.finalScriptWitness.length)\n                out = true;\n        return out;\n    }\n    // https://en.bitcoin.it/wiki/Weight_units\n    get weight() {\n        if (!this.isFinal)\n            throw new Error('Transaction is not finalized');\n        let out = 32;\n        // Outputs\n        const outputs = this.outputs.map(outputBeforeSign);\n        out += 4 * CompactSizeLen.encode(this.outputs.length).length;\n        for (const o of outputs)\n            out += 32 + 4 * VarBytes.encode(o.script).length;\n        // Inputs\n        if (this.hasWitnesses)\n            out += 2;\n        out += 4 * CompactSizeLen.encode(this.inputs.length).length;\n        for (const i of this.inputs) {\n            out += 160 + 4 * VarBytes.encode(i.finalScriptSig || P.EMPTY).length;\n            if (this.hasWitnesses && i.finalScriptWitness)\n                out += RawWitness.encode(i.finalScriptWitness).length;\n        }\n        return out;\n    }\n    get vsize() {\n        return toVsize(this.weight);\n    }\n    toBytes(withScriptSig = false, withWitness = false) {\n        return RawTx.encode({\n            version: this.version,\n            lockTime: this.lockTime,\n            inputs: this.inputs.map(inputBeforeSign).map((i) => ({\n                ...i,\n                finalScriptSig: (withScriptSig && i.finalScriptSig) || P.EMPTY,\n            })),\n            outputs: this.outputs.map(outputBeforeSign),\n            witnesses: this.inputs.map((i) => i.finalScriptWitness || []),\n            segwitFlag: withWitness && this.hasWitnesses,\n        });\n    }\n    get unsignedTx() {\n        return this.toBytes(false, false);\n    }\n    get hex() {\n        return hex.encode(this.toBytes(true, this.hasWitnesses));\n    }\n    get hash() {\n        return hex.encode(u.sha256x2(this.toBytes(true)));\n    }\n    get id() {\n        return hex.encode(u.sha256x2(this.toBytes(true)).reverse());\n    }\n    // Input stuff\n    checkInputIdx(idx) {\n        if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)\n            throw new Error(`Wrong input index=${idx}`);\n    }\n    getInput(idx) {\n        this.checkInputIdx(idx);\n        return cloneDeep(this.inputs[idx]);\n    }\n    get inputsLength() {\n        return this.inputs.length;\n    }\n    // Modification\n    addInput(input, _ignoreSignStatus = false) {\n        if (!_ignoreSignStatus && !this.signStatus().addInput)\n            throw new Error('Tx has signed inputs, cannot add new one');\n        this.inputs.push(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck));\n        return this.inputs.length - 1;\n    }\n    updateInput(idx, input, _ignoreSignStatus = false) {\n        this.checkInputIdx(idx);\n        let allowedFields = undefined;\n        if (!_ignoreSignStatus) {\n            const status = this.signStatus();\n            if (!status.addInput || status.inputs.includes(idx))\n                allowedFields = psbt.PSBTInputUnsignedKeys;\n        }\n        this.inputs[idx] = normalizeInput(input, this.inputs[idx], allowedFields, this.opts.disableScriptCheck, this.opts.allowUnknown);\n    }\n    // Output stuff\n    checkOutputIdx(idx) {\n        if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.outputs.length)\n            throw new Error(`Wrong output index=${idx}`);\n    }\n    getOutput(idx) {\n        this.checkOutputIdx(idx);\n        return cloneDeep(this.outputs[idx]);\n    }\n    getOutputAddress(idx, network = NETWORK) {\n        const out = this.getOutput(idx);\n        if (!out.script)\n            return;\n        return Address(network).encode(OutScript.decode(out.script));\n    }\n    get outputsLength() {\n        return this.outputs.length;\n    }\n    normalizeOutput(o, cur, allowedFields) {\n        let { amount, script } = o;\n        if (amount === undefined)\n            amount = cur?.amount;\n        if (typeof amount !== 'bigint')\n            throw new Error(`Wrong amount type, should be of type bigint in sats, but got ${amount} of type ${typeof amount}`);\n        if (typeof script === 'string')\n            script = hex.decode(script);\n        if (script === undefined)\n            script = cur?.script;\n        let res = { ...cur, ...o, amount, script };\n        if (res.amount === undefined)\n            delete res.amount;\n        res = psbt.mergeKeyMap(psbt.PSBTOutput, res, cur, allowedFields, this.opts.allowUnknown);\n        psbt.PSBTOutputCoder.encode(res);\n        if (res.script &&\n            !this.opts.allowUnknownOutputs &&\n            OutScript.decode(res.script).type === 'unknown') {\n            throw new Error('Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure');\n        }\n        if (!this.opts.disableScriptCheck)\n            checkScript(res.script, res.redeemScript, res.witnessScript);\n        return res;\n    }\n    addOutput(o, _ignoreSignStatus = false) {\n        if (!_ignoreSignStatus && !this.signStatus().addOutput)\n            throw new Error('Tx has signed outputs, cannot add new one');\n        this.outputs.push(this.normalizeOutput(o));\n        return this.outputs.length - 1;\n    }\n    updateOutput(idx, output, _ignoreSignStatus = false) {\n        this.checkOutputIdx(idx);\n        let allowedFields = undefined;\n        if (!_ignoreSignStatus) {\n            const status = this.signStatus();\n            if (!status.addOutput || status.outputs.includes(idx))\n                allowedFields = psbt.PSBTOutputUnsignedKeys;\n        }\n        this.outputs[idx] = this.normalizeOutput(output, this.outputs[idx], allowedFields);\n    }\n    addOutputAddress(address, amount, network = NETWORK) {\n        return this.addOutput({ script: OutScript.encode(Address(network).decode(address)), amount });\n    }\n    // Utils\n    get fee() {\n        let res = 0n;\n        for (const i of this.inputs) {\n            const prevOut = getPrevOut(i);\n            if (!prevOut)\n                throw new Error('Empty input amount');\n            res += prevOut.amount;\n        }\n        const outputs = this.outputs.map(outputBeforeSign);\n        for (const o of outputs)\n            res -= o.amount;\n        return res;\n    }\n    // Signing\n    // Based on https://github.com/bitcoin/bitcoin/blob/5871b5b5ab57a0caf9b7514eb162c491c83281d5/test/functional/test_framework/script.py#L624\n    // There is optimization opportunity to re-use hashes for multiple inputs for witness v0/v1,\n    // but we are trying to be less complicated for audit purpose for now.\n    preimageLegacy(idx, prevOutScript, hashType) {\n        const { isAny, isNone, isSingle } = unpackSighash(hashType);\n        if (idx < 0 || !Number.isSafeInteger(idx))\n            throw new Error(`Invalid input idx=${idx}`);\n        if ((isSingle && idx >= this.outputs.length) || idx >= this.inputs.length)\n            return P.U256BE.encode(1n);\n        prevOutScript = Script.encode(Script.decode(prevOutScript).filter((i) => i !== 'CODESEPARATOR'));\n        let inputs = this.inputs\n            .map(inputBeforeSign)\n            .map((input, inputIdx) => ({\n            ...input,\n            finalScriptSig: inputIdx === idx ? prevOutScript : P.EMPTY,\n        }));\n        if (isAny)\n            inputs = [inputs[idx]];\n        else if (isNone || isSingle) {\n            inputs = inputs.map((input, inputIdx) => ({\n                ...input,\n                sequence: inputIdx === idx ? input.sequence : 0,\n            }));\n        }\n        let outputs = this.outputs.map(outputBeforeSign);\n        if (isNone)\n            outputs = [];\n        else if (isSingle) {\n            outputs = outputs.slice(0, idx).fill(EMPTY_OUTPUT).concat([outputs[idx]]);\n        }\n        const tmpTx = RawTx.encode({\n            lockTime: this.lockTime,\n            version: this.version,\n            segwitFlag: false,\n            inputs,\n            outputs,\n        });\n        return u.sha256x2(tmpTx, P.I32LE.encode(hashType));\n    }\n    preimageWitnessV0(idx, prevOutScript, hashType, amount) {\n        const { isAny, isNone, isSingle } = unpackSighash(hashType);\n        let inputHash = EMPTY32;\n        let sequenceHash = EMPTY32;\n        let outputHash = EMPTY32;\n        const inputs = this.inputs.map(inputBeforeSign);\n        const outputs = this.outputs.map(outputBeforeSign);\n        if (!isAny)\n            inputHash = u.sha256x2(...inputs.map(TxHashIdx.encode));\n        if (!isAny && !isSingle && !isNone)\n            sequenceHash = u.sha256x2(...inputs.map((i) => P.U32LE.encode(i.sequence)));\n        if (!isSingle && !isNone) {\n            outputHash = u.sha256x2(...outputs.map(RawOutput.encode));\n        }\n        else if (isSingle && idx < outputs.length)\n            outputHash = u.sha256x2(RawOutput.encode(outputs[idx]));\n        const input = inputs[idx];\n        return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));\n    }\n    preimageWitnessV1(idx, prevOutScript, hashType, amount, codeSeparator = -1, leafScript, leafVer = 0xc0, annex) {\n        if (!Array.isArray(amount) || this.inputs.length !== amount.length)\n            throw new Error(`Invalid amounts array=${amount}`);\n        if (!Array.isArray(prevOutScript) || this.inputs.length !== prevOutScript.length)\n            throw new Error(`Invalid prevOutScript array=${prevOutScript}`);\n        const out = [\n            P.U8.encode(0),\n            P.U8.encode(hashType), // U8 sigHash\n            P.I32LE.encode(this.version),\n            P.U32LE.encode(this.lockTime),\n        ];\n        const outType = hashType === SignatureHash.DEFAULT ? SignatureHash.ALL : hashType & 0b11;\n        const inType = hashType & SignatureHash.ANYONECANPAY;\n        const inputs = this.inputs.map(inputBeforeSign);\n        const outputs = this.outputs.map(outputBeforeSign);\n        if (inType !== SignatureHash.ANYONECANPAY) {\n            out.push(...[\n                inputs.map(TxHashIdx.encode),\n                amount.map(P.U64LE.encode),\n                prevOutScript.map(VarBytes.encode),\n                inputs.map((i) => P.U32LE.encode(i.sequence)),\n            ].map((i) => u.sha256(concatBytes(...i))));\n        }\n        if (outType === SignatureHash.ALL) {\n            out.push(u.sha256(concatBytes(...outputs.map(RawOutput.encode))));\n        }\n        const spendType = (annex ? 1 : 0) | (leafScript ? 2 : 0);\n        out.push(new Uint8Array([spendType]));\n        if (inType === SignatureHash.ANYONECANPAY) {\n            const inp = inputs[idx];\n            out.push(TxHashIdx.encode(inp), P.U64LE.encode(amount[idx]), VarBytes.encode(prevOutScript[idx]), P.U32LE.encode(inp.sequence));\n        }\n        else\n            out.push(P.U32LE.encode(idx));\n        if (spendType & 1)\n            out.push(u.sha256(VarBytes.encode(annex || P.EMPTY)));\n        if (outType === SignatureHash.SINGLE)\n            out.push(idx < outputs.length ? u.sha256(RawOutput.encode(outputs[idx])) : EMPTY32);\n        if (leafScript)\n            out.push(tapLeafHash(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));\n        return u.tagSchnorr('TapSighash', ...out);\n    }\n    // Signer can be privateKey OR instance of bip32 HD stuff\n    signIdx(privateKey, idx, allowedSighash, _auxRand) {\n        this.checkInputIdx(idx);\n        const input = this.inputs[idx];\n        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);\n        // Handle BIP32 HDKey\n        if (!isBytes(privateKey)) {\n            if (!input.bip32Derivation || !input.bip32Derivation.length)\n                throw new Error('bip32Derivation: empty');\n            const signers = input.bip32Derivation\n                .filter((i) => i[1].fingerprint == privateKey.fingerprint)\n                .map(([pubKey, { path }]) => {\n                let s = privateKey;\n                for (const i of path)\n                    s = s.deriveChild(i);\n                if (!equalBytes(s.publicKey, pubKey))\n                    throw new Error('bip32Derivation: wrong pubKey');\n                if (!s.privateKey)\n                    throw new Error('bip32Derivation: no privateKey');\n                return s;\n            });\n            if (!signers.length)\n                throw new Error(`bip32Derivation: no items with fingerprint=${privateKey.fingerprint}`);\n            let signed = false;\n            for (const s of signers)\n                if (this.signIdx(s.privateKey, idx))\n                    signed = true;\n            return signed;\n        }\n        // Sighash checks\n        // Just for compat with bitcoinjs-lib, so users won't face unexpected behaviour.\n        if (!allowedSighash)\n            allowedSighash = [inputType.defaultSighash];\n        else\n            allowedSighash.forEach(validateSigHash);\n        const sighash = inputType.sighash;\n        if (!allowedSighash.includes(sighash)) {\n            throw new Error(`Input with not allowed sigHash=${sighash}. Allowed: ${allowedSighash.join(', ')}`);\n        }\n        // It is possible to sign these inputs for legacy/segwit v0 (but no taproot!),\n        // however this was because of bug in bitcoin-core, which remains here because of consensus.\n        // If this is absolutely neccessary for your case, please open issue.\n        // We disable it to avoid complicated workflow where SINGLE will block adding new outputs\n        const { sigOutputs } = this.inputSighash(idx);\n        if (sigOutputs === SignatureHash.SINGLE && idx >= this.outputs.length) {\n            throw new Error(`Input with sighash SINGLE, but there is no output with corresponding index=${idx}`);\n        }\n        // Actual signing\n        // Taproot\n        const prevOut = getPrevOut(input);\n        if (inputType.txType === 'taproot') {\n            const prevOuts = this.inputs.map(getPrevOut);\n            const prevOutScript = prevOuts.map((i) => i.script);\n            const amount = prevOuts.map((i) => i.amount);\n            let signed = false;\n            let schnorrPub = u.pubSchnorr(privateKey);\n            let merkleRoot = input.tapMerkleRoot || P.EMPTY;\n            if (input.tapInternalKey) {\n                // internal + tweak = tweaked key\n                // if internal key == current public key, we need to tweak private key,\n                // otherwise sign as is. bitcoinjs implementation always wants tweaked\n                // priv key to be provided\n                const { pubKey, privKey } = getTaprootKeys(privateKey, schnorrPub, input.tapInternalKey, merkleRoot);\n                const [taprootPubKey, _] = u.taprootTweakPubkey(input.tapInternalKey, merkleRoot);\n                if (equalBytes(taprootPubKey, pubKey)) {\n                    const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);\n                    const sig = concatBytes(u.signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);\n                    this.updateInput(idx, { tapKeySig: sig }, true);\n                    signed = true;\n                }\n            }\n            if (input.tapLeafScript) {\n                input.tapScriptSig = input.tapScriptSig || [];\n                for (const [_, _script] of input.tapLeafScript) {\n                    const script = _script.subarray(0, -1);\n                    const scriptDecoded = Script.decode(script);\n                    const ver = _script[_script.length - 1];\n                    const hash = tapLeafHash(script, ver);\n                    // NOTE: no need to tweak internal key here, since we don't support nested p2tr\n                    const pos = scriptDecoded.findIndex((i) => isBytes(i) && equalBytes(i, schnorrPub));\n                    // Skip if there is no public key in tapLeafScript\n                    if (pos === -1)\n                        continue;\n                    const msg = this.preimageWitnessV1(idx, prevOutScript, sighash, amount, undefined, script, ver);\n                    const sig = concatBytes(u.signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);\n                    this.updateInput(idx, { tapScriptSig: [[{ pubKey: schnorrPub, leafHash: hash }, sig]] }, true);\n                    signed = true;\n                }\n            }\n            if (!signed)\n                throw new Error('No taproot scripts signed');\n            return true;\n        }\n        else {\n            // only compressed keys are supported for now\n            const pubKey = u.pubECDSA(privateKey);\n            // TODO: replace with explicit checks\n            // Check if script has public key or its has inside\n            let hasPubkey = false;\n            const pubKeyHash = u.hash160(pubKey);\n            for (const i of Script.decode(inputType.lastScript)) {\n                if (isBytes(i) && (equalBytes(i, pubKey) || equalBytes(i, pubKeyHash)))\n                    hasPubkey = true;\n            }\n            if (!hasPubkey)\n                throw new Error(`Input script doesn't have pubKey: ${inputType.lastScript}`);\n            let hash;\n            if (inputType.txType === 'legacy') {\n                hash = this.preimageLegacy(idx, inputType.lastScript, sighash);\n            }\n            else if (inputType.txType === 'segwit') {\n                let script = inputType.lastScript;\n                // If wpkh OR sh-wpkh, wsh-wpkh is impossible, so looks ok\n                if (inputType.last.type === 'wpkh')\n                    script = OutScript.encode({ type: 'pkh', hash: inputType.last.hash });\n                hash = this.preimageWitnessV0(idx, script, sighash, prevOut.amount);\n            }\n            else\n                throw new Error(`Transaction/sign: unknown tx type: ${inputType.txType}`);\n            const sig = u.signECDSA(hash, privateKey, this.opts.lowR);\n            this.updateInput(idx, {\n                partialSig: [[pubKey, concatBytes(sig, new Uint8Array([sighash]))]],\n            }, true);\n        }\n        return true;\n    }\n    // This is bad API. Will work if user creates and signs tx, but if\n    // there is some complex workflow with exchanging PSBT and signing them,\n    // then it is better to validate which output user signs. How could a better API look like?\n    // Example: user adds input, sends to another party, then signs received input (mixer etc),\n    // another user can add different input for same key and user will sign it.\n    // Even worse: another user can add bip32 derivation, and spend money from different address.\n    // Better api: signIdx\n    sign(privateKey, allowedSighash, _auxRand) {\n        let num = 0;\n        for (let i = 0; i < this.inputs.length; i++) {\n            try {\n                if (this.signIdx(privateKey, i, allowedSighash, _auxRand))\n                    num++;\n            }\n            catch (e) { }\n        }\n        if (!num)\n            throw new Error('No inputs signed');\n        return num;\n    }\n    finalizeIdx(idx) {\n        this.checkInputIdx(idx);\n        if (this.fee < 0n)\n            throw new Error('Outputs spends more than inputs amount');\n        const input = this.inputs[idx];\n        const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);\n        // Taproot finalize\n        if (inputType.txType === 'taproot') {\n            if (input.tapKeySig)\n                input.finalScriptWitness = [input.tapKeySig];\n            else if (input.tapLeafScript && input.tapScriptSig) {\n                // Sort leafs by control block length.\n                const leafs = input.tapLeafScript.sort((a, b) => psbt.TaprootControlBlock.encode(a[0]).length -\n                    psbt.TaprootControlBlock.encode(b[0]).length);\n                for (const [cb, _script] of leafs) {\n                    // Last byte is version\n                    const script = _script.slice(0, -1);\n                    const ver = _script[_script.length - 1];\n                    const outScript = OutScript.decode(script);\n                    const hash = tapLeafHash(script, ver);\n                    const scriptSig = input.tapScriptSig.filter((i) => equalBytes(i[0].leafHash, hash));\n                    let signatures = [];\n                    if (outScript.type === 'tr_ms') {\n                        const m = outScript.m;\n                        const pubkeys = outScript.pubkeys;\n                        let added = 0;\n                        for (const pub of pubkeys) {\n                            const sigIdx = scriptSig.findIndex((i) => equalBytes(i[0].pubKey, pub));\n                            // Should have exact amount of signatures (more -- will fail)\n                            if (added === m || sigIdx === -1) {\n                                signatures.push(P.EMPTY);\n                                continue;\n                            }\n                            signatures.push(scriptSig[sigIdx][1]);\n                            added++;\n                        }\n                        // Should be exact same as m\n                        if (added !== m)\n                            continue;\n                    }\n                    else if (outScript.type === 'tr_ns') {\n                        for (const pub of outScript.pubkeys) {\n                            const sigIdx = scriptSig.findIndex((i) => equalBytes(i[0].pubKey, pub));\n                            if (sigIdx === -1)\n                                continue;\n                            signatures.push(scriptSig[sigIdx][1]);\n                        }\n                        if (signatures.length !== outScript.pubkeys.length)\n                            continue;\n                    }\n                    else if (outScript.type === 'unknown' && this.opts.allowUnknownInputs) {\n                        // Trying our best to sign what we can\n                        const scriptDecoded = Script.decode(script);\n                        signatures = scriptSig\n                            .map(([{ pubKey }, signature]) => {\n                            const pos = scriptDecoded.findIndex((i) => isBytes(i) && equalBytes(i, pubKey));\n                            if (pos === -1)\n                                throw new Error('finalize/taproot: cannot find position of pubkey in script');\n                            return { signature, pos };\n                        })\n                            // Reverse order (because witness is stack and we take last element first from it)\n                            .sort((a, b) => a.pos - b.pos)\n                            .map((i) => i.signature);\n                        if (!signatures.length)\n                            continue;\n                    }\n                    else {\n                        const custom = this.opts.customScripts;\n                        if (custom) {\n                            for (const c of custom) {\n                                if (!c.finalizeTaproot)\n                                    continue;\n                                const scriptDecoded = Script.decode(script);\n                                const csEncoded = c.encode(scriptDecoded);\n                                if (csEncoded === undefined)\n                                    continue;\n                                const finalized = c.finalizeTaproot(script, csEncoded, scriptSig);\n                                if (!finalized)\n                                    continue;\n                                input.finalScriptWitness = finalized.concat(psbt.TaprootControlBlock.encode(cb));\n                                input.finalScriptSig = P.EMPTY;\n                                cleanFinalInput(input);\n                                return;\n                            }\n                        }\n                        throw new Error('Finalize: Unknown tapLeafScript');\n                    }\n                    // Witness is stack, so last element will be used first\n                    input.finalScriptWitness = signatures\n                        .reverse()\n                        .concat([script, psbt.TaprootControlBlock.encode(cb)]);\n                    break;\n                }\n                if (!input.finalScriptWitness)\n                    throw new Error('finalize/taproot: empty witness');\n            }\n            else\n                throw new Error('finalize/taproot: unknown input');\n            input.finalScriptSig = P.EMPTY;\n            cleanFinalInput(input);\n            return;\n        }\n        if (!input.partialSig || !input.partialSig.length)\n            throw new Error('Not enough partial sign');\n        let inputScript = P.EMPTY;\n        let witness = [];\n        // TODO: move input scripts closer to payments/output scripts\n        // Multisig\n        if (inputType.last.type === 'ms') {\n            const m = inputType.last.m;\n            const pubkeys = inputType.last.pubkeys;\n            let signatures = [];\n            // partial: [pubkey, sign]\n            for (const pub of pubkeys) {\n                const sign = input.partialSig.find((s) => equalBytes(pub, s[0]));\n                if (!sign)\n                    continue;\n                signatures.push(sign[1]);\n            }\n            signatures = signatures.slice(0, m);\n            if (signatures.length !== m) {\n                throw new Error(`Multisig: wrong signatures count, m=${m} n=${pubkeys.length} signatures=${signatures.length}`);\n            }\n            inputScript = Script.encode([0, ...signatures]);\n        }\n        else if (inputType.last.type === 'pk') {\n            inputScript = Script.encode([input.partialSig[0][1]]);\n        }\n        else if (inputType.last.type === 'pkh') {\n            inputScript = Script.encode([input.partialSig[0][1], input.partialSig[0][0]]);\n        }\n        else if (inputType.last.type === 'wpkh') {\n            inputScript = P.EMPTY;\n            witness = [input.partialSig[0][1], input.partialSig[0][0]];\n        }\n        else if (inputType.last.type === 'unknown' && !this.opts.allowUnknownInputs)\n            throw new Error('Unknown inputs not allowed');\n        // Create final scripts (generic part)\n        let finalScriptSig, finalScriptWitness;\n        if (inputType.type.includes('wsh-')) {\n            // P2WSH\n            if (inputScript.length && inputType.lastScript.length) {\n                witness = Script.decode(inputScript).map((i) => {\n                    if (i === 0)\n                        return P.EMPTY;\n                    if (isBytes(i))\n                        return i;\n                    throw new Error(`Wrong witness op=${i}`);\n                });\n            }\n            witness = witness.concat(inputType.lastScript);\n        }\n        if (inputType.txType === 'segwit')\n            finalScriptWitness = witness;\n        if (inputType.type.startsWith('sh-wsh-')) {\n            finalScriptSig = Script.encode([Script.encode([0, u.sha256(inputType.lastScript)])]);\n        }\n        else if (inputType.type.startsWith('sh-')) {\n            finalScriptSig = Script.encode([...Script.decode(inputScript), inputType.lastScript]);\n        }\n        else if (inputType.type.startsWith('wsh-')) {\n        }\n        else if (inputType.txType !== 'segwit')\n            finalScriptSig = inputScript;\n        if (!finalScriptSig && !finalScriptWitness)\n            throw new Error('Unknown error finalizing input');\n        if (finalScriptSig)\n            input.finalScriptSig = finalScriptSig;\n        if (finalScriptWitness)\n            input.finalScriptWitness = finalScriptWitness;\n        cleanFinalInput(input);\n    }\n    finalize() {\n        for (let i = 0; i < this.inputs.length; i++)\n            this.finalizeIdx(i);\n    }\n    extract() {\n        if (!this.isFinal)\n            throw new Error('Transaction has unfinalized inputs');\n        if (!this.outputs.length)\n            throw new Error('Transaction has no outputs');\n        if (this.fee < 0n)\n            throw new Error('Outputs spends more than inputs amount');\n        return this.toBytes(true, true);\n    }\n    combine(other) {\n        for (const k of ['PSBTVersion', 'version', 'lockTime']) {\n            if (this.opts[k] !== other.opts[k]) {\n                throw new Error(`Transaction/combine: different ${k} this=${this.opts[k]} other=${other.opts[k]}`);\n            }\n        }\n        for (const k of ['inputs', 'outputs']) {\n            if (this[k].length !== other[k].length) {\n                throw new Error(`Transaction/combine: different ${k} length this=${this[k].length} other=${other[k].length}`);\n            }\n        }\n        const thisUnsigned = this.global.unsignedTx ? RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;\n        const otherUnsigned = other.global.unsignedTx\n            ? RawOldTx.encode(other.global.unsignedTx)\n            : P.EMPTY;\n        if (!equalBytes(thisUnsigned, otherUnsigned))\n            throw new Error(`Transaction/combine: different unsigned tx`);\n        this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global, undefined, this.opts.allowUnknown);\n        for (let i = 0; i < this.inputs.length; i++)\n            this.updateInput(i, other.inputs[i], true);\n        for (let i = 0; i < this.outputs.length; i++)\n            this.updateOutput(i, other.outputs[i], true);\n        return this;\n    }\n    clone() {\n        // deepClone probably faster, but this enforces that encoding is valid\n        return Transaction.fromPSBT(this.toPSBT(this.opts.PSBTVersion), this.opts);\n    }\n}\nexport function PSBTCombine(psbts) {\n    if (!psbts || !Array.isArray(psbts) || !psbts.length)\n        throw new Error('PSBTCombine: wrong PSBT list');\n    const tx = Transaction.fromPSBT(psbts[0]);\n    for (let i = 1; i < psbts.length; i++)\n        tx.combine(Transaction.fromPSBT(psbts[i]));\n    return tx.toPSBT();\n}\n// Copy-pasted from bip32 derive, maybe do something like 'bip32.parsePath'?\nconst HARDENED_OFFSET = 0x80000000;\nexport function bip32Path(path) {\n    const out = [];\n    if (!/^[mM]'?/.test(path))\n        throw new Error('Path must start with \"m\" or \"M\"');\n    if (/^[mM]'?$/.test(path))\n        return out;\n    const parts = path.replace(/^[mM]'?\\//, '').split('/');\n    for (const c of parts) {\n        const m = /^(\\d+)('?)$/.exec(c);\n        if (!m || m.length !== 3)\n            throw new Error(`Invalid child index: ${c}`);\n        let idx = +m[1];\n        if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET)\n            throw new Error('Invalid index');\n        // hardened key\n        if (m[2] === \"'\")\n            idx += HARDENED_OFFSET;\n        out.push(idx);\n    }\n    return out;\n}\n//# sourceMappingURL=transaction.js.map"],"names":["PubKeyECDSA","P.validate","P.bytes","pub","validatePubkey","PubT","PubKeySchnorr","SignatureSchnorr","sig","BIP32Der","P.struct","P.U32BE","P.array","P.U32LE","TaprootBIP32Der","CompactSizeLen","GlobalXPUB","tapScriptSigKey","_TaprootControlBlock","P.U8","TaprootControlBlock","cb","tapTree","VarBytes","BytesInf","Bytes20","Bytes32","PSBTGlobal","RawOldTx","PSBTInput","RawTx","RawOutput","RawWitness","PSBTInputFinalKeys","PSBTInputUnsignedKeys","PSBTOutput","P.I64LE","PSBTOutputUnsignedKeys","PSBTKeyPair","P.NULL","P.prefix","PSBTKeyInfo","info","type","kc","vc","reqInc","allowInc","silentIgnore","PSBTKeyMap","psbtEnum","byType","k","num","P.wrap","w","value","out","name","val","P.EMPTY","kv","v","a","b","compareBytes","key","r","raw","noKey","elm","_name","hex","PSBTInputCoder","i","PSBTOutputCoder","o","PSBTGlobalCoder","g","inp","_RawPSBTV0","P.magic","P.string","_RawPSBTV2","P.apply","P.tuple","P.hex","CompactSize","P.coders","validatePSBTFields","version","lst","cleanPSBTFields","_k","validatePSBT","tx","inputCount","inputsLeft","outputCount","outputsLeft","mergeKeyMap","cur","allowedFields","allowUnknown","res","_","kC","vC","cannotChange","oldKV","newKV","map","add","kStr","oldVal","newVal","equalBytes","RawPSBTV0","RawPSBTV2","EMPTY32","EMPTY_OUTPUT","toVsize","weight","PRECISION","DEFAULT_VERSION","DEFAULT_LOCKTIME","DEFAULT_SEQUENCE","def","cloneDeep","obj","isBytes","SignatureHash","SigHash","SigHashNames","u.reverseObject","getTaprootKeys","privKey","pubKey","internalKey","merkleRoot","u.taprootTweakPrivKey","u.pubSchnorr","outputBeforeSign","inputBeforeSign","cleanFinalInput","psbt.PSBTInputFinalKeys","TxHashIdx","validateSigHash","s","unpackSighash","hashType","masked","validateOpts","opts","_opts","cs","validateInput","last","prevOut","Transaction","txid","getPrevOut","input","normalizeInput","disableScriptCheck","nonWitnessUtxo","psbt.mergeKeyMap","psbt.PSBTInput","psbt.PSBTInputCoder","checkScript","getInputType","allowLegacyWitnessUtxo","txType","defaultSighash","first","OutScript","stack","child","lastScript","parsed","psbt_","psbt.RawPSBTV0","e0","psbt.RawPSBTV2","PSBTVersion","unsigned","lockTime","j","inputs","psbt.cleanPSBTFields","outputs","psbt.PSBTOutput","global","height","heightCnt","time","timeCnt","idx","inputSighash","sighash","sigOutputs","addInput","addOutput","sigInputs","withScriptSig","withWitness","u.sha256x2","_ignoreSignStatus","status","psbt.PSBTInputUnsignedKeys","network","NETWORK","Address","amount","script","psbt.PSBTOutputCoder","output","psbt.PSBTOutputUnsignedKeys","address","prevOutScript","isAny","isNone","isSingle","P.U256BE","Script","inputIdx","tmpTx","P.I32LE","inputHash","sequenceHash","outputHash","P.U64LE","codeSeparator","leafScript","leafVer","annex","outType","inType","u.sha256","concatBytes","spendType","tapLeafHash","u.tagSchnorr","privateKey","allowedSighash","_auxRand","inputType","signers","path","signed","prevOuts","schnorrPub","taprootPubKey","u.taprootTweakPubkey","hash","u.signSchnorr","_script","scriptDecoded","ver","msg","u.pubECDSA","hasPubkey","pubKeyHash","u.hash160","u.signECDSA","leafs","psbt.TaprootControlBlock","outScript","scriptSig","signatures","pubkeys","added","sigIdx","signature","pos","custom","c","csEncoded","finalized","inputScript","witness","m","sign","finalScriptSig","finalScriptWitness","other","thisUnsigned","otherUnsigned","psbt.PSBTGlobal"],"mappings":"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","x_google_ignoreList":[0,1]}