@bitgo-beta/utxo-ord 1.1.3-alpha.412 → 1.1.3-alpha.414

package/dist/esm/SatPoint.js

@@ -0,0 +1,43 @@
+/*
+
+https://github.com/casey/ord/blob/master/bip.mediawiki#terminology-and-notation
+
+> A satpoint may be used to indicate the location of a sat within an output.
+> A satpoint consists of an outpoint, i.e., a transaction ID and output index, with the addition of
+> the offset of the ordinal within that output. For example, if the sat in question is at offset 6
+> in the first output of a transaction, its satpoint is:
+> `680df1e4d43016571e504b0b142ee43c5c0b83398a97bdcfd94ea6f287322d22:0:6`
+
+*/
+import { bitgo } from '@bitgo-beta/utxo-lib';
+export function parseSatPoint(p) {
+    const parts = p.split(':');
+    if (parts.length !== 3) {
+        throw new Error(`expected format txid:vout:sat`);
+    }
+    const [txid, vout, offsetStr] = parts;
+    const offset = BigInt(offsetStr);
+    if (offset.toString() !== offsetStr) {
+        throw new Error(`SatPoint offset must be base-10`);
+    }
+    if (offset < 0) {
+        throw new Error(`SatPoint offset must be positive`);
+    }
+    return {
+        ...bitgo.parseOutputId([txid, vout].join(':')),
+        offset,
+    };
+}
+export function formatSatPoint(p) {
+    return `${p.txid}:${p.vout}:${p.offset}`;
+}
+export function isSatPoint(v) {
+    try {
+        parseSatPoint(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/SatRange.d.ts

@@ -0,0 +1,26 @@
+export declare class InvalidSatRange extends Error {
+    start: bigint;
+    end: bigint;
+    constructor(message: string, start: bigint, end: bigint);
+}
+/**
+ * Range of satoshi, inclusive.
+ * Inscriptions have start === end.
+ */
+export declare class SatRange {
+    start: bigint;
+    end: bigint;
+    constructor(start: bigint, end: bigint);
+    /**
+     * @param offset
+     * @return SatRange with start and end shifted by offset
+     */
+    shiftedBy(offset: bigint): SatRange;
+    /** @return true iff this intersects with _other_ */
+    intersectsWith(other: bigint | SatRange): boolean;
+    /** @return true iff this is superset of _other_. */
+    isSupersetOf(other: bigint | SatRange): boolean;
+    toString(): string;
+    size(): bigint;
+}
+//# sourceMappingURL=SatRange.d.ts.map

package/dist/esm/SatRange.js

@@ -0,0 +1,53 @@
+export class InvalidSatRange extends Error {
+    constructor(message, start, end) {
+        super(message);
+        this.start = start;
+        this.end = end;
+    }
+}
+function toRange(v) {
+    return typeof v === 'bigint' ? new SatRange(v, v) : v;
+}
+/**
+ * Range of satoshi, inclusive.
+ * Inscriptions have start === end.
+ */
+export class SatRange {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+        if (start < 0 || end < 0 || end < start) {
+            throw new InvalidSatRange(`Invalid SatRange [${start}, ${end}]`, start, end);
+        }
+    }
+    /**
+     * @param offset
+     * @return SatRange with start and end shifted by offset
+     */
+    shiftedBy(offset) {
+        return new SatRange(this.start + offset, this.end + offset);
+    }
+    /** @return true iff this intersects with _other_ */
+    intersectsWith(other) {
+        other = toRange(other);
+        if (this.start <= other.start) {
+            return other.start <= this.end;
+        }
+        return other.intersectsWith(this);
+    }
+    /** @return true iff this is superset of _other_. */
+    isSupersetOf(other) {
+        other = toRange(other);
+        return this.start <= other.start && other.end <= this.end;
+    }
+    toString() {
+        if (this.start === this.end) {
+            return `[${this.start}]`;
+        }
+        return `[${this.start}..${this.end}]`;
+    }
+    size() {
+        return this.end - this.start + BigInt(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/combinations.d.ts

@@ -0,0 +1,2 @@
+export declare function powerset<T>(arr: T[]): T[][];
+//# sourceMappingURL=combinations.d.ts.map

package/dist/esm/combinations.js

@@ -0,0 +1,10 @@
+export function powerset(arr) {
+    if (arr.length === 0) {
+        return [[]];
+    }
+    else {
+        const [a, ...rest] = arr;
+        return powerset(rest).flatMap((s) => [[a, ...s], s]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tYmluYXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbWJpbmF0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsUUFBUSxDQUFJLEdBQVE7SUFDbEMsSUFBSSxHQUFHLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3JCLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNkLENBQUM7U0FBTSxDQUFDO1FBQ04sTUFBTSxDQUFDLENBQUMsRUFBRSxHQUFHLElBQUksQ0FBQyxHQUFHLEdBQUcsQ0FBQztRQUN6QixPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIHBvd2Vyc2V0PFQ+KGFycjogVFtdKTogVFtdW10ge1xuICBpZiAoYXJyLmxlbmd0aCA9PT0gMCkge1xuICAgIHJldHVybiBbW11dO1xuICB9IGVsc2Uge1xuICAgIGNvbnN0IFthLCAuLi5yZXN0XSA9IGFycjtcbiAgICByZXR1cm4gcG93ZXJzZXQocmVzdCkuZmxhdE1hcCgocykgPT4gW1thLCAuLi5zXSwgc10pO1xuICB9XG59XG4iXX0=

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * https://github.com/casey/ord/blob/0.5.1/bip.mediawiki
+ */
+export * from './SatRange';
+export * from './OrdOutput';
+export * from './OutputLayout';
+export * from './SatPoint';
+export * from './psbt';
+export * as inscriptions from './inscriptions';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+/**
+ * https://github.com/casey/ord/blob/0.5.1/bip.mediawiki
+ */
+export * from './SatRange';
+export * from './OrdOutput';
+export * from './OutputLayout';
+export * from './SatPoint';
+export * from './psbt';
+export * as inscriptions from './inscriptions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9jYXNleS9vcmQvYmxvYi8wLjUuMS9iaXAubWVkaWF3aWtpXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9TYXRSYW5nZSc7XG5leHBvcnQgKiBmcm9tICcuL09yZE91dHB1dCc7XG5leHBvcnQgKiBmcm9tICcuL091dHB1dExheW91dCc7XG5leHBvcnQgKiBmcm9tICcuL1NhdFBvaW50JztcbmV4cG9ydCAqIGZyb20gJy4vcHNidCc7XG5leHBvcnQgKiBhcyBpbnNjcmlwdGlvbnMgZnJvbSAnLi9pbnNjcmlwdGlvbnMnO1xuIl19

package/dist/esm/inscriptions.d.ts

@@ -0,0 +1,31 @@
+import { Network } from '@bitgo-beta/utxo-lib';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { PreparedInscriptionRevealData } from '@bitgo-beta/sdk-core';
+/**
+ * @param pubkey
+ * @param contentType
+ * @param inscriptionData
+ * @param network
+ * @returns PreparedInscriptionRevealData
+ */
+export declare function createInscriptionRevealData(pubkey: Buffer, contentType: string, inscriptionData: Buffer, network: Network): PreparedInscriptionRevealData;
+/**
+ * @param pubkey
+ * @param contentType
+ * @param inscriptionData
+ * @returns inscription address
+ */
+export declare function createOutputScriptForInscription(pubkey: Buffer, contentType: string, inscriptionData: Buffer): Buffer;
+/**
+ *
+ * @param privateKey
+ * @param tapLeafScript
+ * @param commitAddress
+ * @param recipientAddress
+ * @param unsignedCommitTx
+ * @param network
+ *
+ * @return a fully signed reveal transaction
+ */
+export declare function signRevealTransaction(privateKey: Buffer, tapLeafScript: utxolib.bitgo.TapLeafScript, commitAddress: string, recipientAddress: string, unsignedCommitTx: Buffer, network: Network): utxolib.bitgo.UtxoPsbt;
+//# sourceMappingURL=inscriptions.d.ts.map

package/dist/esm/inscriptions.js

@@ -0,0 +1,164 @@
+/*
+Functions for dealing with inscriptions.
+
+See https://docs.ordinals.com/inscriptions.html
+*/
+import * as assert from 'assert';
+import { p2trPayments as payments, ecc as eccLib, script as bscript, bitgo, address, taproot, ECPair, } from '@bitgo-beta/utxo-lib';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+const OPS = bscript.OPS;
+const MAX_LENGTH_TAP_DATA_PUSH = 520;
+// default "postage" amount
+// https://github.com/ordinals/ord/blob/0.24.2/src/lib.rs#L149
+const DEFAULT_POSTAGE_AMOUNT = BigInt(10000);
+/**
+ * The max size of an individual OP_PUSH in a Taproot script is 520 bytes. This
+ * function splits inscriptionData into an array buffer of 520 bytes length.
+ * https://docs.ordinals.com/inscriptions.html
+ * @param inscriptionData
+ * @param chunkSize
+ */
+function splitBuffer(inscriptionData, chunkSize) {
+    const pushDataBuffers = [];
+    for (let i = 0; i < inscriptionData.length; i += chunkSize) {
+        pushDataBuffers.push(inscriptionData.slice(i, i + chunkSize));
+    }
+    return pushDataBuffers;
+}
+/**
+ *
+ * @returns inscription payment object
+ * @param pubkey
+ * @param contentType
+ * @param inscriptionData
+ */
+function createPaymentForInscription(pubkey, contentType, inscriptionData) {
+    const dataPushBuffers = splitBuffer(inscriptionData, MAX_LENGTH_TAP_DATA_PUSH);
+    const uncompiledScript = [
+        pubkey,
+        OPS.OP_CHECKSIG,
+        OPS.OP_FALSE,
+        OPS.OP_IF,
+        Buffer.from('ord', 'ascii'),
+        1, // these two lines should be combined as a single OPS.OP_1,
+        1, // but `ord`'s decoder has a bug so it has to be like this
+        Buffer.from(contentType, 'ascii'),
+        OPS.OP_0,
+        ...dataPushBuffers,
+        OPS.OP_ENDIF,
+    ];
+    const compiledScript = bscript.compile(uncompiledScript);
+    const redeem = {
+        output: compiledScript,
+        depth: 0,
+    };
+    return payments.p2tr({ redeems: [redeem], redeemIndex: 0 }, { eccLib });
+}
+/**
+ * @param payment
+ * @param controlBlock
+ * @param commitOutput
+ * @param network
+ * @return virtual size of a transaction with a single inscription reveal input and a single commitOutput
+ */
+function getInscriptionRevealSize(payment, controlBlock, commitOutput, network) {
+    const psbt = bitgo.createPsbtForNetwork({ network });
+    const parsedControlBlock = taproot.parseControlBlock(eccLib, controlBlock);
+    const leafHash = taproot.getTapleafHash(eccLib, parsedControlBlock, payment.redeem?.output);
+    psbt.addInput({
+        hash: Buffer.alloc(32),
+        index: 0,
+        witnessUtxo: { script: commitOutput, value: BigInt(100000) },
+        tapLeafScript: [
+            {
+                controlBlock,
+                script: payment.redeem?.output,
+                leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,
+            },
+        ],
+    });
+    psbt.addOutput({ script: commitOutput, value: DEFAULT_POSTAGE_AMOUNT });
+    psbt.signTaprootInput(0, {
+        publicKey: Buffer.alloc(32),
+        signSchnorr(hash) {
+            // dummy schnorr-sized signature
+            return Buffer.alloc(64);
+        },
+    }, [leafHash]);
+    psbt.finalizeTapInputWithSingleLeafScriptAndSignature(0);
+    return psbt.extractTransaction(/* disableFeeCheck */ true).virtualSize();
+}
+/**
+ * @param pubkey
+ * @param contentType
+ * @param inscriptionData
+ * @param network
+ * @returns PreparedInscriptionRevealData
+ */
+export function createInscriptionRevealData(pubkey, contentType, inscriptionData, network) {
+    const payment = createPaymentForInscription(pubkey, contentType, inscriptionData);
+    const { output: commitOutput, controlBlock } = payment;
+    assert.ok(commitOutput);
+    assert.ok(controlBlock);
+    assert.ok(payment.redeem?.output);
+    const commitAddress = address.fromOutputScript(commitOutput, network);
+    const tapLeafScript = [
+        {
+            controlBlock,
+            script: payment.redeem?.output,
+            leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,
+        },
+    ];
+    const revealTransactionVSize = getInscriptionRevealSize(payment, controlBlock, commitOutput, network);
+    return {
+        address: commitAddress,
+        revealTransactionVSize,
+        tapLeafScript: tapLeafScript[0],
+    };
+}
+/**
+ * @param pubkey
+ * @param contentType
+ * @param inscriptionData
+ * @returns inscription address
+ */
+export function createOutputScriptForInscription(pubkey, contentType, inscriptionData) {
+    const payment = createPaymentForInscription(pubkey, contentType, inscriptionData);
+    assert.ok(payment.output, 'Failed to create inscription output script');
+    return payment.output;
+}
+/**
+ *
+ * @param privateKey
+ * @param tapLeafScript
+ * @param commitAddress
+ * @param recipientAddress
+ * @param unsignedCommitTx
+ * @param network
+ *
+ * @return a fully signed reveal transaction
+ */
+export function signRevealTransaction(privateKey, tapLeafScript, commitAddress, recipientAddress, unsignedCommitTx, network) {
+    const unserCommitTxn = utxolib.bitgo.createTransactionFromBuffer(unsignedCommitTx, network);
+    const hash = unserCommitTxn.getHash();
+    const commitOutput = utxolib.address.toOutputScript(commitAddress, network);
+    const vout = unserCommitTxn.outs.findIndex((out) => out.script.equals(commitOutput));
+    if (vout === -1) {
+        throw new Error('Invalid commit transaction');
+    }
+    const psbt = bitgo.createPsbtForNetwork({ network });
+    psbt.addInput({
+        hash,
+        index: vout,
+        witnessUtxo: { script: commitOutput, value: BigInt(unserCommitTxn.outs[vout].value) },
+        tapLeafScript: [tapLeafScript],
+    });
+    const recipientOutput = address.toOutputScript(recipientAddress, network);
+    psbt.addOutput({ script: recipientOutput, value: BigInt(10000) });
+    const signer = ECPair.fromPrivateKey(privateKey);
+    const parsedControlBlock = taproot.parseControlBlock(eccLib, tapLeafScript.controlBlock);
+    const leafHash = taproot.getTapleafHash(eccLib, parsedControlBlock, tapLeafScript.script);
+    psbt.signTaprootInput(0, signer, [leafHash]);
+    return psbt;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inscriptions.js","sourceRoot":"","sources":["../../src/inscriptions.ts"],"names":[],"mappings":"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","sourcesContent":["/*\nFunctions for dealing with inscriptions.\n\nSee https://docs.ordinals.com/inscriptions.html\n*/\n\nimport * as assert from 'assert';\nimport {\n  p2trPayments as payments,\n  ecc as eccLib,\n  script as bscript,\n  Payment,\n  Network,\n  bitgo,\n  address,\n  taproot,\n  ECPair,\n} from '@bitgo-beta/utxo-lib';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { PreparedInscriptionRevealData } from '@bitgo-beta/sdk-core';\n\nconst OPS = bscript.OPS;\nconst MAX_LENGTH_TAP_DATA_PUSH = 520;\n// default \"postage\" amount\n// https://github.com/ordinals/ord/blob/0.24.2/src/lib.rs#L149\nconst DEFAULT_POSTAGE_AMOUNT = BigInt(10_000);\n\n/**\n * The max size of an individual OP_PUSH in a Taproot script is 520 bytes. This\n * function splits inscriptionData into an array buffer of 520 bytes length.\n * https://docs.ordinals.com/inscriptions.html\n * @param inscriptionData\n * @param chunkSize\n */\nfunction splitBuffer(inscriptionData: Buffer, chunkSize: number) {\n  const pushDataBuffers: Buffer[] = [];\n  for (let i = 0; i < inscriptionData.length; i += chunkSize) {\n    pushDataBuffers.push(inscriptionData.slice(i, i + chunkSize));\n  }\n\n  return pushDataBuffers;\n}\n\n/**\n *\n * @returns inscription payment object\n * @param pubkey\n * @param contentType\n * @param inscriptionData\n */\nfunction createPaymentForInscription(pubkey: Buffer, contentType: string, inscriptionData: Buffer): Payment {\n  const dataPushBuffers = splitBuffer(inscriptionData, MAX_LENGTH_TAP_DATA_PUSH);\n\n  const uncompiledScript = [\n    pubkey,\n    OPS.OP_CHECKSIG,\n    OPS.OP_FALSE,\n    OPS.OP_IF,\n    Buffer.from('ord', 'ascii'),\n    1, // these two lines should be combined as a single OPS.OP_1,\n    1, // but `ord`'s decoder has a bug so it has to be like this\n    Buffer.from(contentType, 'ascii'),\n    OPS.OP_0,\n    ...dataPushBuffers,\n    OPS.OP_ENDIF,\n  ];\n\n  const compiledScript = bscript.compile(uncompiledScript);\n  const redeem: Payment = {\n    output: compiledScript,\n    depth: 0,\n  };\n\n  return payments.p2tr({ redeems: [redeem], redeemIndex: 0 }, { eccLib });\n}\n\n/**\n * @param payment\n * @param controlBlock\n * @param commitOutput\n * @param network\n * @return virtual size of a transaction with a single inscription reveal input and a single commitOutput\n */\nfunction getInscriptionRevealSize(\n  payment: Payment,\n  controlBlock: Buffer,\n  commitOutput: Buffer,\n  network: Network\n): number {\n  const psbt = bitgo.createPsbtForNetwork({ network });\n  const parsedControlBlock = taproot.parseControlBlock(eccLib, controlBlock);\n  const leafHash = taproot.getTapleafHash(eccLib, parsedControlBlock, payment.redeem?.output as Buffer);\n\n  psbt.addInput({\n    hash: Buffer.alloc(32),\n    index: 0,\n    witnessUtxo: { script: commitOutput, value: BigInt(100_000) },\n    tapLeafScript: [\n      {\n        controlBlock,\n        script: payment.redeem?.output as Buffer,\n        leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,\n      },\n    ],\n  });\n  psbt.addOutput({ script: commitOutput, value: DEFAULT_POSTAGE_AMOUNT });\n\n  psbt.signTaprootInput(\n    0,\n    {\n      publicKey: Buffer.alloc(32),\n      signSchnorr(hash: Buffer): Buffer {\n        // dummy schnorr-sized signature\n        return Buffer.alloc(64);\n      },\n    },\n    [leafHash]\n  );\n\n  psbt.finalizeTapInputWithSingleLeafScriptAndSignature(0);\n  return psbt.extractTransaction(/* disableFeeCheck */ true).virtualSize();\n}\n\n/**\n * @param pubkey\n * @param contentType\n * @param inscriptionData\n * @param network\n * @returns PreparedInscriptionRevealData\n */\nexport function createInscriptionRevealData(\n  pubkey: Buffer,\n  contentType: string,\n  inscriptionData: Buffer,\n  network: Network\n): PreparedInscriptionRevealData {\n  const payment = createPaymentForInscription(pubkey, contentType, inscriptionData);\n\n  const { output: commitOutput, controlBlock } = payment;\n  assert.ok(commitOutput);\n  assert.ok(controlBlock);\n  assert.ok(payment.redeem?.output);\n  const commitAddress = address.fromOutputScript(commitOutput, network);\n\n  const tapLeafScript: utxolib.bitgo.TapLeafScript[] = [\n    {\n      controlBlock,\n      script: payment.redeem?.output,\n      leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,\n    },\n  ];\n  const revealTransactionVSize = getInscriptionRevealSize(payment, controlBlock, commitOutput, network);\n\n  return {\n    address: commitAddress,\n    revealTransactionVSize,\n    tapLeafScript: tapLeafScript[0],\n  };\n}\n\n/**\n * @param pubkey\n * @param contentType\n * @param inscriptionData\n * @returns inscription address\n */\nexport function createOutputScriptForInscription(pubkey: Buffer, contentType: string, inscriptionData: Buffer): Buffer {\n  const payment = createPaymentForInscription(pubkey, contentType, inscriptionData);\n\n  assert.ok(payment.output, 'Failed to create inscription output script');\n  return payment.output;\n}\n\n/**\n *\n * @param privateKey\n * @param tapLeafScript\n * @param commitAddress\n * @param recipientAddress\n * @param unsignedCommitTx\n * @param network\n *\n * @return a fully signed reveal transaction\n */\nexport function signRevealTransaction(\n  privateKey: Buffer,\n  tapLeafScript: utxolib.bitgo.TapLeafScript,\n  commitAddress: string,\n  recipientAddress: string,\n  unsignedCommitTx: Buffer,\n  network: Network\n): utxolib.bitgo.UtxoPsbt {\n  const unserCommitTxn = utxolib.bitgo.createTransactionFromBuffer(unsignedCommitTx, network);\n  const hash = unserCommitTxn.getHash();\n  const commitOutput = utxolib.address.toOutputScript(commitAddress, network);\n  const vout = unserCommitTxn.outs.findIndex((out) => out.script.equals(commitOutput));\n\n  if (vout === -1) {\n    throw new Error('Invalid commit transaction');\n  }\n\n  const psbt = bitgo.createPsbtForNetwork({ network });\n  psbt.addInput({\n    hash,\n    index: vout,\n    witnessUtxo: { script: commitOutput, value: BigInt(unserCommitTxn.outs[vout].value) },\n    tapLeafScript: [tapLeafScript],\n  });\n\n  const recipientOutput = address.toOutputScript(recipientAddress, network);\n  psbt.addOutput({ script: recipientOutput, value: BigInt(10_000) });\n\n  const signer = ECPair.fromPrivateKey(privateKey);\n  const parsedControlBlock = taproot.parseControlBlock(eccLib, tapLeafScript.controlBlock);\n  const leafHash = taproot.getTapleafHash(eccLib, parsedControlBlock, tapLeafScript.script as Buffer);\n  psbt.signTaprootInput(0, signer, [leafHash]);\n\n  return psbt;\n}\n"]}

package/dist/esm/psbt.d.ts

@@ -0,0 +1,67 @@
+import { Network, bitgo } from '@bitgo-beta/utxo-lib';
+import { SatPoint } from './SatPoint';
+import { OutputLayout } from './OutputLayout';
+type WalletUnspent = bitgo.WalletUnspent<bigint>;
+export type WalletOutputPath = {
+    chain: bitgo.ChainCode;
+    index: number;
+};
+export type WalletInputBuilder = {
+    walletKeys: bitgo.RootWalletKeys;
+    signer: bitgo.KeyName;
+    cosigner: bitgo.KeyName;
+};
+/**
+ * Describes all outputs of an inscription transaction
+ */
+export type InscriptionTransactionOutputs = {
+    inscriptionRecipient: string | Buffer;
+    changeOutputs: [WalletOutputPath, WalletOutputPath];
+};
+/** @deprecated */
+export type InscriptionOutputs = InscriptionTransactionOutputs;
+export type InscriptionTransactionConstraints = {
+    feeRateSatKB: number;
+    minChangeOutput?: bigint;
+    minInscriptionOutput?: bigint;
+    maxInscriptionOutput?: bigint;
+};
+export declare const DefaultInscriptionConstraints: {
+    minChangeOutput: bigint;
+    minInscriptionOutput: bigint;
+    maxInscriptionOutput: bigint;
+};
+export declare function createPsbtFromOutputLayout(network: Network, inputBuilder: WalletInputBuilder, unspents: WalletUnspent[], outputs: InscriptionTransactionOutputs, outputLayout: OutputLayout): bitgo.UtxoPsbt;
+/**
+ * @param inputs - inscription input must come first
+ * @param satPoint - location of the inscription
+ * @param outputs
+ * @param constraints
+ * @param minimizeInputs
+ */
+export declare function findOutputLayoutForWalletUnspents(inputs: WalletUnspent[], satPoint: SatPoint, outputs: InscriptionTransactionOutputs, constraints: InscriptionTransactionConstraints, { minimizeInputs }?: {
+    minimizeInputs?: boolean | undefined;
+}): {
+    inputs: WalletUnspent[];
+    layout: OutputLayout;
+} | undefined;
+export declare const MAX_UNSPENTS_FOR_OUTPUT_LAYOUT = 5;
+export declare class ErrorNoLayout extends Error {
+    constructor();
+}
+/**
+ * @param network
+ * @param inputBuilder
+ * @param unspent
+ * @param satPoint
+ * @param outputs
+ * @param constraints
+ * @param supplementaryUnspents - additional inputs to cover fee.
+ * @param [minimizeInputs=true] - try to find input combination with minimal fees. Limits supplementaryUnspents to 4.
+ */
+export declare function createPsbtForSingleInscriptionPassingTransaction(network: Network, inputBuilder: WalletInputBuilder, unspent: WalletUnspent | WalletUnspent[], satPoint: SatPoint, outputs: InscriptionTransactionOutputs, constraints: InscriptionTransactionConstraints, { supplementaryUnspents, minimizeInputs, }?: {
+    supplementaryUnspents?: WalletUnspent[];
+    minimizeInputs?: boolean;
+}): bitgo.UtxoPsbt;
+export {};
+//# sourceMappingURL=psbt.d.ts.map