@kukks/bitcoin-descriptors 3.0.2

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export type { KeyInfo, Expansion } from './types.js';
+export type { OutputInstance } from './descriptors.js';
+export { DescriptorsFactory, OutputConstructor } from './descriptors.js';
+export { DescriptorChecksum as checksum } from './checksum.js';
+import * as signers from './signers.js';
+export { signers };
+export { keyExpressionBIP32 } from './keyExpressions.js';
+import * as scriptExpressions from './scriptExpressions.js';
+export { scriptExpressions };
+export type { PsbtLike } from './psbt.js';
+export { networks } from './networks.js';
+export type { Network } from './networks.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+export { DescriptorsFactory } from './descriptors.js';
+export { DescriptorChecksum as checksum } from './checksum.js';
+import * as signers from './signers.js';
+export { signers };
+export { keyExpressionBIP32 } from './keyExpressions.js';
+import * as scriptExpressions from './scriptExpressions.js';
+export { scriptExpressions };
+export { networks } from './networks.js';

package/dist/keyExpressions.d.ts

@@ -0,0 +1,59 @@
+import { Network } from './networks.js';
+import type { ECPairAPI, BIP32API, BIP32Interface } from './types.js';
+import type { KeyInfo } from './types.js';
+/**
+ * Parses a key expression (xpub, xprv, pubkey or wif) into {@link KeyInfo | `KeyInfo`}.
+ *
+ * For example, given this `keyExpression`: `"[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*"`, this is its parsed result:
+ *
+ * ```javascript
+ *  {
+ *    keyExpression:
+ *      "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
+ *    keyPath: '/1/2/3/4/*',
+ *    originPath: "/49'/0'/0'",
+ *    path: "m/49'/0'/0'/1/2/3/4/*",
+ *    // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
+ *  }
+ * ```
+ */
+export declare function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32, network }: {
+    keyExpression: string;
+    /** @default networks.bitcoin */
+    network?: Network;
+    /**
+     * Indicates if this key expression belongs to a a SegWit output. When set,
+     * further checks are done to ensure the public key (if present in the
+     * expression) is compressed (33 bytes).
+     */
+    isSegwit?: boolean;
+    /**
+     * Indicates if this key expression belongs to a Taproot output. For Taproot,
+     * the key must be represented as an x-only public key (32 bytes).
+     * If a 33-byte compressed pubkey is derived, it is converted to its x-only
+     * representation.
+     */
+    isTaproot?: boolean;
+    ECPair: ECPairAPI;
+    BIP32: BIP32API;
+}): KeyInfo;
+/**
+ * Constructs a key expression string from its constituent components.
+ *
+ * This function essentially performs the reverse operation of
+ * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}. For detailed
+ * explanations and examples of the terms used here, refer to
+ * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}.
+ */
+export declare function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    originPath: string;
+    change?: number | undefined;
+    index?: number | undefined | '*';
+    keyPath?: string | undefined;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}): string;

package/dist/keyExpressions.js

@@ -0,0 +1,197 @@
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+import { networks } from './networks.js';
+import { hex } from '@scure/base';
+import { concatBytes } from '@scure/btc-signer/utils.js';
+import * as RE from './re.js';
+const derivePath = (node, path) => {
+    if (typeof path !== 'string') {
+        throw new Error(`Error: invalid derivation path ${path}`);
+    }
+    const parsedPath = path.replaceAll('H', "'").replaceAll('h', "'").slice(1);
+    const splitPath = parsedPath.split('/');
+    for (const element of splitPath) {
+        const unhardened = element.endsWith("'") ? element.slice(0, -1) : element;
+        if (!Number.isInteger(Number(unhardened)) ||
+            Number(unhardened) >= 0x80000000)
+            throw new Error(`Error: BIP 32 path element overflow`);
+    }
+    return node.derivePath(parsedPath);
+};
+/**
+ * Parses a key expression (xpub, xprv, pubkey or wif) into {@link KeyInfo | `KeyInfo`}.
+ *
+ * For example, given this `keyExpression`: `"[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*"`, this is its parsed result:
+ *
+ * ```javascript
+ *  {
+ *    keyExpression:
+ *      "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
+ *    keyPath: '/1/2/3/4/*',
+ *    originPath: "/49'/0'/0'",
+ *    path: "m/49'/0'/0'/1/2/3/4/*",
+ *    // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
+ *  }
+ * ```
+ */
+export function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32, network = networks.bitcoin }) {
+    let pubkey; //won't be computed for ranged keyExpressions
+    let ecpair;
+    let bip32;
+    let masterFingerprint;
+    let originPath;
+    let keyPath;
+    let path;
+    const isRanged = keyExpression.indexOf('*') !== -1;
+    const reKeyExp = isTaproot
+        ? RE.reTaprootKeyExp
+        : isSegwit
+            ? RE.reSegwitKeyExp
+            : RE.reNonSegwitKeyExp;
+    const rePubKey = isTaproot
+        ? RE.reTaprootPubKey
+        : isSegwit
+            ? RE.reSegwitPubKey
+            : RE.reNonSegwitPubKey;
+    //Validate the keyExpression:
+    const keyExpressions = keyExpression.match(reKeyExp);
+    if (keyExpressions === null || keyExpressions[0] !== keyExpression) {
+        throw new Error(`Error: expected a keyExpression but got ${keyExpression}`);
+    }
+    const reOriginAnchoredStart = RegExp(String.raw `^(${RE.reOrigin})?`); //starts with ^origin
+    const mOrigin = keyExpression.match(reOriginAnchoredStart);
+    if (mOrigin) {
+        const bareOrigin = mOrigin[0].replace(/[[\]]/g, ''); //strip the "[" and "]" in [origin]
+        const reMasterFingerprintAnchoredStart = String.raw `^(${RE.reMasterFingerprint})`;
+        const mMasterFingerprint = bareOrigin.match(reMasterFingerprintAnchoredStart);
+        const masterFingerprintHex = mMasterFingerprint
+            ? mMasterFingerprint[0]
+            : '';
+        originPath = bareOrigin.replace(masterFingerprintHex, '');
+        if (masterFingerprintHex.length > 0) {
+            if (masterFingerprintHex.length !== 8)
+                throw new Error(`Error: masterFingerprint ${masterFingerprintHex} invalid for keyExpression: ${keyExpression}`);
+            masterFingerprint = hex.decode(masterFingerprintHex);
+        }
+    }
+    //Remove the origin (if it exists) and store result in actualKey
+    const actualKey = keyExpression.replace(reOriginAnchoredStart, '');
+    let mPubKey, mWIF, mXpubKey, mXprvKey;
+    //match pubkey:
+    if ((mPubKey = actualKey.match(RE.anchorStartAndEnd(rePubKey))) !== null) {
+        pubkey = hex.decode(mPubKey[0]);
+        if (isTaproot && pubkey.length === 32)
+            //convert the xonly point to a compressed point assuming even parity
+            pubkey = concatBytes(Uint8Array.from([0x02]), pubkey);
+        ecpair = ECPair.fromPublicKey(pubkey, { network });
+        //Validate the pubkey (compressed or uncompressed)
+        if (!ECPair.isPoint(pubkey) ||
+            !(pubkey.length === 33 || pubkey.length === 65)) {
+            throw new Error(`Error: invalid pubkey`);
+        }
+        //Do an extra check in case we know this pubkey refers to a segwit input
+        if (typeof isSegwit === 'boolean' &&
+            isSegwit &&
+            pubkey.length !== 33 //Inside wpkh and wsh, only compressed public keys are permitted.
+        ) {
+            throw new Error(`Error: invalid pubkey`);
+        }
+        //match WIF:
+    }
+    else if ((mWIF = actualKey.match(RE.anchorStartAndEnd(RE.reWIF))) !== null) {
+        ecpair = ECPair.fromWIF(mWIF[0], network);
+        //fromWIF will throw if the wif is not valid
+        pubkey = ecpair.publicKey;
+        //Check segwit requires compressed keys
+        if (typeof isSegwit === 'boolean' && isSegwit && pubkey.length !== 33) {
+            throw new Error(`Error: invalid pubkey`);
+        }
+        //match xpub:
+    }
+    else if ((mXpubKey = actualKey.match(RE.anchorStartAndEnd(RE.reXpubKey))) !== null) {
+        const xPubKey = mXpubKey[0];
+        const xPub = xPubKey.match(RE.reXpub)?.[0];
+        if (!xPub)
+            throw new Error(`Error: xpub could not be matched`);
+        bip32 = BIP32.fromBase58(xPub, network);
+        const mPath = xPubKey.match(RE.rePath);
+        if (mPath !== null) {
+            keyPath = xPubKey.match(RE.rePath)?.[0];
+            if (!keyPath)
+                throw new Error(`Error: could not extract a path`);
+            //fromBase58 and derivePath will throw if xPub or path are not valid
+            if (!isRanged)
+                pubkey = derivePath(bip32, keyPath).publicKey;
+        }
+        else {
+            pubkey = bip32.publicKey;
+        }
+        //match xprv:
+    }
+    else if ((mXprvKey = actualKey.match(RE.anchorStartAndEnd(RE.reXprvKey))) !== null) {
+        const xPrvKey = mXprvKey[0];
+        const xPrv = xPrvKey.match(RE.reXprv)?.[0];
+        if (!xPrv)
+            throw new Error(`Error: xprv could not be matched`);
+        bip32 = BIP32.fromBase58(xPrv, network);
+        const mPath = xPrvKey.match(RE.rePath);
+        if (mPath !== null) {
+            keyPath = xPrvKey.match(RE.rePath)?.[0];
+            if (!keyPath)
+                throw new Error(`Error: could not extract a path`);
+            //fromBase58 and derivePath will throw if xPrv or path are not valid
+            if (!isRanged)
+                pubkey = derivePath(bip32, keyPath).publicKey;
+        }
+        else {
+            pubkey = bip32.publicKey;
+        }
+    }
+    else {
+        throw new Error(`Error: could not get pubkey for keyExpression ${keyExpression}`);
+    }
+    if (originPath || keyPath) {
+        path = `m${originPath ?? ''}${keyPath ?? ''}`;
+    }
+    if (pubkey !== undefined && isTaproot && pubkey.length === 33)
+        // If we get a 33-byte compressed key, drop the first byte.
+        pubkey = pubkey.slice(1, 33);
+    return {
+        keyExpression,
+        ...(pubkey !== undefined ? { pubkey } : {}),
+        ...(ecpair !== undefined ? { ecpair } : {}),
+        ...(bip32 !== undefined ? { bip32 } : {}),
+        ...(masterFingerprint !== undefined ? { masterFingerprint } : {}),
+        ...(originPath !== undefined && originPath !== '' ? { originPath } : {}),
+        ...(keyPath !== undefined && keyPath !== '' ? { keyPath } : {}),
+        ...(path !== undefined ? { path } : {})
+    };
+}
+function assertChangeIndexKeyPath({ change, index, keyPath }) {
+    if (!((change === undefined && index === undefined) ||
+        (change !== undefined && index !== undefined)))
+        throw new Error(`Error: Pass change and index or neither`);
+    if ((change !== undefined) === (keyPath !== undefined))
+        throw new Error(`Error: Pass either change and index or a keyPath`);
+}
+/**
+ * Constructs a key expression string from its constituent components.
+ *
+ * This function essentially performs the reverse operation of
+ * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}. For detailed
+ * explanations and examples of the terms used here, refer to
+ * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}.
+ */
+export function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic = true }) {
+    assertChangeIndexKeyPath({ change, index, keyPath });
+    const masterFingerprint = masterNode.fingerprint;
+    const origin = `[${hex.encode(masterFingerprint)}${originPath}]`;
+    const xpub = isPublic
+        ? masterNode.derivePath(`m${originPath}`).neutered().toBase58().toString()
+        : masterNode.derivePath(`m${originPath}`).toBase58().toString();
+    const keyRoot = `${origin}${xpub}`;
+    if (keyPath !== undefined)
+        return `${keyRoot}${keyPath}`;
+    else
+        return `${keyRoot}/${change}/${index}`;
+}

package/dist/miniscript.d.ts

@@ -0,0 +1,55 @@
+import { Network } from './networks.js';
+import type { ECPairAPI } from './types.js';
+import type { BIP32API } from './types.js';
+import type { PartialSig } from './types.js';
+import type { Preimage, TimeConstraints, ExpansionMap } from './types.js';
+/**
+ * Expand a miniscript to a generalized form using variables instead of key
+ * expressions. Variables will be of this form: @0, @1, ...
+ * This is done so that it can be compiled with compileMiniscript and
+ * satisfied with satisfier.
+ * Also compute pubkeys from descriptors to use them later.
+ */
+export declare function expandMiniscript({ miniscript, isSegwit, isTaproot, network, ECPair, BIP32 }: {
+    miniscript: string;
+    isSegwit: boolean;
+    isTaproot: boolean;
+    network?: Network;
+    ECPair: ECPairAPI;
+    BIP32: BIP32API;
+}): {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+};
+export declare function miniscript2Script({ expandedMiniscript, expansionMap }: {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+}): Uint8Array;
+/**
+ * Assumptions:
+ * The attacker does not have access to any of the private keys of public keys
+ * that participate in the Script.
+ *
+ * The attacker only has access to hash preimages that honest users have access
+ * to as well.
+ *
+ * Pass timeConstraints to search for the first solution with this nLockTime and
+ * nSequence. Throw if no solution is possible using these constraints.
+ *
+ * Don't pass timeConstraints (this is the default) if you want to get the
+ * smallest size solution altogether.
+ *
+ * If a solution is not found this function throws.
+ */
+export declare function satisfyMiniscript({ expandedMiniscript, expansionMap, signatures, preimages, timeConstraints }: {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+    signatures?: PartialSig[];
+    preimages?: Preimage[];
+    timeConstraints?: TimeConstraints;
+}): {
+    scriptSatisfaction: Uint8Array;
+    nLockTime: number | undefined;
+    nSequence: number | undefined;
+};
+export { numberEncodeAsm } from './scriptUtils.js';

package/dist/miniscript.js

@@ -0,0 +1,163 @@
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+import { networks } from './networks.js';
+import { fromASM, numberEncodeAsm } from './scriptUtils.js';
+import { hash160 } from '@scure/btc-signer/utils.js';
+import { hex } from '@scure/base';
+import { parseKeyExpression } from './keyExpressions.js';
+import * as RE from './re.js';
+import { compileMiniscript, satisfier } from '@bitcoinerlab/miniscript';
+/**
+ * Expand a miniscript to a generalized form using variables instead of key
+ * expressions. Variables will be of this form: @0, @1, ...
+ * This is done so that it can be compiled with compileMiniscript and
+ * satisfied with satisfier.
+ * Also compute pubkeys from descriptors to use them later.
+ */
+export function expandMiniscript({ miniscript, isSegwit, isTaproot, network = networks.bitcoin, ECPair, BIP32 }) {
+    if (isTaproot)
+        throw new Error('Taproot miniscript not yet supported.');
+    const reKeyExp = isTaproot
+        ? RE.reTaprootKeyExp
+        : isSegwit
+            ? RE.reSegwitKeyExp
+            : RE.reNonSegwitKeyExp;
+    const expansionMap = {};
+    const expandedMiniscript = miniscript.replace(RegExp(reKeyExp, 'g'), (keyExpression) => {
+        const key = '@' + Object.keys(expansionMap).length;
+        expansionMap[key] = parseKeyExpression({
+            keyExpression,
+            isSegwit,
+            network,
+            ECPair,
+            BIP32
+        });
+        return key;
+    });
+    //Do some assertions. Miniscript must not have duplicate keys, also all
+    //keyExpressions must produce a valid pubkey (unless it's ranged and we want
+    //to expand a generalized form, then we don't check)
+    const pubkeysHex = Object.values(expansionMap)
+        .filter(keyInfo => keyInfo.keyExpression.indexOf('*') === -1)
+        .map(keyInfo => {
+        if (!keyInfo.pubkey)
+            throw new Error(`Error: keyExpression ${keyInfo.keyExpression} does not have a pubkey`);
+        return hex.encode(keyInfo.pubkey);
+    });
+    if (new Set(pubkeysHex).size !== pubkeysHex.length) {
+        throw new Error(`Error: miniscript ${miniscript} is not sane: contains duplicate public keys.`);
+    }
+    return { expandedMiniscript, expansionMap };
+}
+/**
+ * Particularize an expanded ASM expression using the variables in
+ * expansionMap.
+ * This is the kind of the opposite to what expandMiniscript does.
+ * Signatures and preimages are already subsituted by the satisfier calling
+ * this function.
+ */
+function substituteAsm({ expandedAsm, expansionMap }) {
+    //Replace back variables into the pubkeys previously computed.
+    let asm = Object.keys(expansionMap).reduce((accAsm, key) => {
+        const pubkey = expansionMap[key]?.pubkey;
+        if (!pubkey) {
+            throw new Error(`Error: invalid expansionMap for ${key}`);
+        }
+        return accAsm
+            .replaceAll(`<${key}>`, `<${hex.encode(pubkey)}>`)
+            .replaceAll(`<HASH160(${key})>`, `<${hex.encode(hash160(pubkey))}>`);
+    }, expandedAsm);
+    //Now clean it and prepare it so that fromASM can be called:
+    asm = asm
+        .trim()
+        //Replace one or more consecutive whitespace characters (spaces, tabs,
+        //or line breaks) with a single space.
+        .replace(/\s+/g, ' ')
+        //Now encode numbers to little endian hex. Note that numbers are not
+        //enclosed in <>, since <> represents hex code already encoded.
+        //The regex below will match one or more digits within a string,
+        //except if the sequence is surrounded by "<" and ">"
+        .replace(/(<\d+>)|\b\d+\b/g, match => match.startsWith('<') ? match : numberEncodeAsm(Number(match)))
+        //we don't have numbers anymore, now it's safe to remove < and > since we
+        //know that every remaining is either an op_code or a hex encoded number
+        .replace(/[<>]/g, '');
+    return asm;
+}
+export function miniscript2Script({ expandedMiniscript, expansionMap }) {
+    const compiled = compileMiniscript(expandedMiniscript);
+    if (compiled.issane !== true) {
+        throw new Error(`Error: Miniscript ${expandedMiniscript} is not sane`);
+    }
+    return fromASM(substituteAsm({ expandedAsm: compiled.asm, expansionMap }));
+}
+/**
+ * Assumptions:
+ * The attacker does not have access to any of the private keys of public keys
+ * that participate in the Script.
+ *
+ * The attacker only has access to hash preimages that honest users have access
+ * to as well.
+ *
+ * Pass timeConstraints to search for the first solution with this nLockTime and
+ * nSequence. Throw if no solution is possible using these constraints.
+ *
+ * Don't pass timeConstraints (this is the default) if you want to get the
+ * smallest size solution altogether.
+ *
+ * If a solution is not found this function throws.
+ */
+export function satisfyMiniscript({ expandedMiniscript, expansionMap, signatures = [], preimages = [], timeConstraints }) {
+    //convert 'sha256(6c...33)' to: { ['<sha256_preimage(6c...33)>']: '10...5f'}
+    const preimageMap = {};
+    preimages.forEach(preimage => {
+        preimageMap['<' + preimage.digest.replace('(', '_preimage(') + '>'] =
+            '<' + preimage.preimage + '>';
+    });
+    //convert the pubkeys in signatures into [{['<sig(@0)>']: '30450221'}, ...]
+    //get the keyExpressions: @0, @1 from the keys in expansionMap
+    const expandedSignatureMap = {};
+    signatures.forEach(signature => {
+        const pubkeyHex = hex.encode(signature.pubkey);
+        const keyExpression = Object.keys(expansionMap).find(k => {
+            const pk = expansionMap[k]?.pubkey;
+            return pk ? hex.encode(pk) === pubkeyHex : false;
+        });
+        expandedSignatureMap['<sig(' + keyExpression + ')>'] =
+            '<' + hex.encode(signature.signature) + '>';
+    });
+    const expandedKnownsMap = { ...preimageMap, ...expandedSignatureMap };
+    const knowns = Object.keys(expandedKnownsMap);
+    //satisfier verifies again internally whether expandedKnownsMap with given knowns is sane
+    const { nonMalleableSats } = satisfier(expandedMiniscript, { knowns });
+    if (!Array.isArray(nonMalleableSats) || !nonMalleableSats[0])
+        throw new Error(`Error: unresolvable miniscript ${expandedMiniscript}`);
+    let sat;
+    if (!timeConstraints) {
+        sat = nonMalleableSats[0];
+    }
+    else {
+        sat = nonMalleableSats.find(nonMalleableSat => nonMalleableSat.nSequence === timeConstraints.nSequence &&
+            nonMalleableSat.nLockTime === timeConstraints.nLockTime);
+        if (sat === undefined) {
+            throw new Error(`Error: unresolvable miniscript ${expandedMiniscript}. Could not find solutions for sequence ${timeConstraints.nSequence} & locktime=${timeConstraints.nLockTime}. Signatures are applied to a hash that depends on sequence and locktime. Did you provide all the signatures wrt the signers keys declared and include all preimages?`);
+        }
+    }
+    //substitute signatures and preimages:
+    let expandedAsm = sat.asm;
+    //replace in expandedAsm all the <sig(@0)> and <sha256_preimage(6c...33)>
+    //to <304...01> and <107...5f> ...
+    for (const search in expandedKnownsMap) {
+        const replace = expandedKnownsMap[search];
+        if (!replace || replace === '<>')
+            throw new Error(`Error: invalid expandedKnownsMap`);
+        expandedAsm = expandedAsm.replaceAll(search, replace);
+    }
+    const scriptSatisfaction = fromASM(substituteAsm({ expandedAsm, expansionMap }));
+    return {
+        scriptSatisfaction,
+        nLockTime: sat.nLockTime,
+        nSequence: sat.nSequence
+    };
+}
+// Re-export numberEncodeAsm from scriptUtils
+export { numberEncodeAsm } from './scriptUtils.js';

package/dist/networks.d.ts

@@ -0,0 +1,23 @@
+export interface Network {
+    messagePrefix: string;
+    bech32: string;
+    bip32: {
+        public: number;
+        private: number;
+    };
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+}
+export declare const networks: {
+    bitcoin: Network;
+    testnet: Network;
+    regtest: Network;
+};
+/** Convert our Network to the format expected by @scure/btc-signer */
+export declare function toBtcSignerNetwork(network: Network): {
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+};

package/dist/networks.js

@@ -0,0 +1,37 @@
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+export const networks = {
+    bitcoin: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'bc',
+        bip32: { public: 0x0488b21e, private: 0x0488ade4 },
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80
+    },
+    testnet: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'tb',
+        bip32: { public: 0x043587cf, private: 0x04358394 },
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef
+    },
+    regtest: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'bcrt',
+        bip32: { public: 0x043587cf, private: 0x04358394 },
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef
+    }
+};
+/** Convert our Network to the format expected by @scure/btc-signer */
+export function toBtcSignerNetwork(network) {
+    return {
+        bech32: network.bech32,
+        pubKeyHash: network.pubKeyHash,
+        scriptHash: network.scriptHash,
+        wif: network.wif
+    };
+}

package/dist/psbt.d.ts

@@ -0,0 +1,38 @@
+import * as btc from '@scure/btc-signer';
+import type { KeyInfo } from './types.js';
+type PsbtLike = InstanceType<typeof btc.Transaction>;
+/**
+ * Computes final scripts for miniscript-based inputs.
+ *
+ * @param scriptSatisfaction - The script satisfaction (input script data)
+ * @param lockingScript - The "meaningful" locking script (witnessScript or redeemScript)
+ * @param isSegwit - Whether this is a segwit input
+ * @param isP2SH - Whether this is a P2SH input
+ * @param network - The network
+ * @returns Object with finalScriptSig and finalScriptWitness (as Uint8Array[])
+ */
+export declare function computeFinalScripts(scriptSatisfaction: Uint8Array, lockingScript: Uint8Array, isSegwit: boolean, isP2SH: boolean, redeemScript?: Uint8Array): {
+    finalScriptSig: Uint8Array | undefined;
+    finalScriptWitness: Uint8Array[] | undefined;
+};
+/**
+ * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
+ */
+export declare function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, witnessScript, redeemScript, rbf }: {
+    psbt: PsbtLike;
+    vout: number;
+    txHex?: string;
+    txId?: string;
+    value?: number | bigint;
+    sequence: number | undefined;
+    locktime: number | undefined;
+    keysInfo: KeyInfo[];
+    scriptPubKey: Uint8Array;
+    isSegwit: boolean;
+    /** for taproot **/
+    tapInternalKey?: Uint8Array | undefined;
+    witnessScript: Uint8Array | undefined;
+    redeemScript: Uint8Array | undefined;
+    rbf: boolean;
+}): number;
+export type { PsbtLike };