@bitgo-beta/utxo-ord 1.0.1-beta.192 → 1.0.1-beta.1921

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,12 @@
+/**
+ * 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';
+export type { TapLeafScript, PreparedInscriptionRevealData } from './inscriptions';
+export type { WalletUnspent } from './psbt';
+//# sourceMappingURL=index.d.ts.map

package/dist/{src → esm}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AACnF,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC"}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9jYXNleS9vcmQvYmxvYi8wLjUuMS9iaXAubWVkaWF3aWtpXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9TYXRSYW5nZSc7XG5leHBvcnQgKiBmcm9tICcuL09yZE91dHB1dCc7XG5leHBvcnQgKiBmcm9tICcuL091dHB1dExheW91dCc7XG5leHBvcnQgKiBmcm9tICcuL1NhdFBvaW50JztcbmV4cG9ydCAqIGZyb20gJy4vcHNidCc7XG5leHBvcnQgKiBhcyBpbnNjcmlwdGlvbnMgZnJvbSAnLi9pbnNjcmlwdGlvbnMnO1xuZXhwb3J0IHR5cGUgeyBUYXBMZWFmU2NyaXB0LCBQcmVwYXJlZEluc2NyaXB0aW9uUmV2ZWFsRGF0YSB9IGZyb20gJy4vaW5zY3JpcHRpb25zJztcbmV4cG9ydCB0eXBlIHsgV2FsbGV0VW5zcGVudCB9IGZyb20gJy4vcHNidCc7XG4iXX0=

package/dist/esm/inscriptions.d.ts

@@ -0,0 +1,58 @@
+import { type TapLeafScript, type CoinName } from '@bitgo/wasm-utxo';
+export type { TapLeafScript };
+/**
+ * Prepared data for an inscription reveal transaction.
+ * Compatible with sdk-core's PreparedInscriptionRevealData.
+ */
+export type PreparedInscriptionRevealData = {
+    /** The commit address (derived from outputScript for the given network) */
+    address: string;
+    /** Estimated virtual size of the reveal transaction */
+    revealTransactionVSize: number;
+    /** Tap leaf script for spending the commit output */
+    tapLeafScript: TapLeafScript;
+};
+/**
+ * BIP32-like interface compatible with both utxo-lib and wasm-utxo BIP32 types.
+ * The publicKey can be Buffer (utxo-lib) or Uint8Array (wasm-utxo).
+ */
+export interface BIP32Like {
+    publicKey: Uint8Array;
+}
+/** Input type for inscription functions - either a BIP32-like key or raw public key bytes */
+export type KeyInput = BIP32Like | Uint8Array;
+/**
+ * Create the P2TR output script for an inscription.
+ *
+ * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @returns The P2TR output script for the inscription commit address
+ */
+export declare function createOutputScriptForInscription(key: KeyInput, contentType: string, inscriptionData: Uint8Array): Uint8Array;
+/**
+ * Create inscription reveal data including the commit address and tap leaf script.
+ *
+ * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @param coinName - Coin name (e.g., "btc", "tbtc")
+ * @returns PreparedInscriptionRevealData with address, vsize estimate, and tap leaf script
+ */
+export declare function createInscriptionRevealData(key: KeyInput, contentType: string, inscriptionData: Uint8Array, coinName: CoinName): PreparedInscriptionRevealData;
+/**
+ * Sign a reveal transaction.
+ *
+ * Creates and signs the reveal transaction that spends from the commit output
+ * and sends the inscription to the recipient.
+ *
+ * @param privateKey - 32-byte private key
+ * @param tapLeafScript - The tap leaf script from createInscriptionRevealData
+ * @param commitAddress - The commit address
+ * @param recipientAddress - Where to send the inscription
+ * @param unsignedCommitTx - The unsigned commit transaction bytes
+ * @param coinName - Coin name (e.g., "btc", "tbtc")
+ * @returns The signed PSBT as bytes
+ */
+export declare function signRevealTransaction(privateKey: Uint8Array, tapLeafScript: TapLeafScript, commitAddress: string, recipientAddress: string, unsignedCommitTx: Uint8Array, coinName: CoinName): Uint8Array;
+//# sourceMappingURL=inscriptions.d.ts.map

package/dist/esm/inscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inscriptions.d.ts","sourceRoot":"","sources":["../../src/inscriptions.ts"],"names":[],"mappings":"AAQA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,aAAa,EAAE,CAAC;AAM9B;;;GAGG;AACH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qDAAqD;IACrD,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,UAAU,CAAC;CACvB;AAED,6FAA6F;AAC7F,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AA0B9C;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,QAAQ,EACb,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,UAAU,GAC1B,UAAU,CAKZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,QAAQ,EACb,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,UAAU,EAC3B,QAAQ,EAAE,QAAQ,GACjB,6BAA6B,CAc/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,UAAU,EAC5B,QAAQ,EAAE,QAAQ,GACjB,UAAU,CAcZ"}

package/dist/esm/inscriptions.js

@@ -0,0 +1,89 @@
+/*
+Functions for dealing with inscriptions.
+
+Wrapper around @bitgo/wasm-utxo inscription functions for utxo-ord consumers.
+
+See https://docs.ordinals.com/inscriptions.html
+*/
+import { inscriptions as wasmInscriptions, address as wasmAddress, Transaction, ECPair, } from '@bitgo/wasm-utxo';
+// default "postage" amount
+// https://github.com/ordinals/ord/blob/0.24.2/src/lib.rs#L149
+const DEFAULT_POSTAGE_SATS = BigInt(10000);
+function isBIP32Like(key) {
+    return typeof key === 'object' && key !== null && 'publicKey' in key && !ArrayBuffer.isView(key);
+}
+/**
+ * Extract compressed public key from key input.
+ * Handles BIP32-like objects and raw pubkey bytes (32 or 33 bytes).
+ */
+function getCompressedPublicKey(key) {
+    const pubkey = isBIP32Like(key) ? key.publicKey : key;
+    if (pubkey.length === 33) {
+        return pubkey;
+    }
+    if (pubkey.length === 32) {
+        // x-only pubkey - prepend 0x02 parity byte to make compressed
+        const compressedPubkey = new Uint8Array(33);
+        compressedPubkey[0] = 0x02;
+        compressedPubkey.set(pubkey, 1);
+        return compressedPubkey;
+    }
+    throw new Error(`Invalid public key length: ${pubkey.length}. Expected 32 or 33 bytes.`);
+}
+/**
+ * Create the P2TR output script for an inscription.
+ *
+ * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @returns The P2TR output script for the inscription commit address
+ */
+export function createOutputScriptForInscription(key, contentType, inscriptionData) {
+    const compressedPubkey = getCompressedPublicKey(key);
+    const ecpair = ECPair.fromPublicKey(compressedPubkey);
+    const result = wasmInscriptions.createInscriptionRevealData(ecpair, contentType, inscriptionData);
+    return result.outputScript;
+}
+/**
+ * Create inscription reveal data including the commit address and tap leaf script.
+ *
+ * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @param coinName - Coin name (e.g., "btc", "tbtc")
+ * @returns PreparedInscriptionRevealData with address, vsize estimate, and tap leaf script
+ */
+export function createInscriptionRevealData(key, contentType, inscriptionData, coinName) {
+    const compressedPubkey = getCompressedPublicKey(key);
+    const ecpair = ECPair.fromPublicKey(compressedPubkey);
+    const wasmResult = wasmInscriptions.createInscriptionRevealData(ecpair, contentType, inscriptionData);
+    // Convert outputScript to address for the given network
+    const address = wasmAddress.fromOutputScriptWithCoin(wasmResult.outputScript, coinName);
+    return {
+        address,
+        revealTransactionVSize: wasmResult.revealTransactionVSize,
+        tapLeafScript: wasmResult.tapLeafScript,
+    };
+}
+/**
+ * Sign a reveal transaction.
+ *
+ * Creates and signs the reveal transaction that spends from the commit output
+ * and sends the inscription to the recipient.
+ *
+ * @param privateKey - 32-byte private key
+ * @param tapLeafScript - The tap leaf script from createInscriptionRevealData
+ * @param commitAddress - The commit address
+ * @param recipientAddress - Where to send the inscription
+ * @param unsignedCommitTx - The unsigned commit transaction bytes
+ * @param coinName - Coin name (e.g., "btc", "tbtc")
+ * @returns The signed PSBT as bytes
+ */
+export function signRevealTransaction(privateKey, tapLeafScript, commitAddress, recipientAddress, unsignedCommitTx, coinName) {
+    const ecpair = ECPair.fromPrivateKey(privateKey);
+    const commitTx = Transaction.fromBytes(unsignedCommitTx);
+    const commitOutputScript = wasmAddress.toOutputScriptWithCoin(commitAddress, coinName);
+    const recipientOutputScript = wasmAddress.toOutputScriptWithCoin(recipientAddress, coinName);
+    return wasmInscriptions.signRevealTransaction(ecpair, tapLeafScript, commitTx, commitOutputScript, recipientOutputScript, DEFAULT_POSTAGE_SATS);
+}
+//# 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\nWrapper around @bitgo/wasm-utxo inscription functions for utxo-ord consumers.\n\nSee https://docs.ordinals.com/inscriptions.html\n*/\n\nimport {\n  inscriptions as wasmInscriptions,\n  address as wasmAddress,\n  Transaction,\n  ECPair,\n  type TapLeafScript,\n  type CoinName,\n} from '@bitgo/wasm-utxo';\n\nexport type { TapLeafScript };\n\n// default \"postage\" amount\n// https://github.com/ordinals/ord/blob/0.24.2/src/lib.rs#L149\nconst DEFAULT_POSTAGE_SATS = BigInt(10_000);\n\n/**\n * Prepared data for an inscription reveal transaction.\n * Compatible with sdk-core's PreparedInscriptionRevealData.\n */\nexport type PreparedInscriptionRevealData = {\n  /** The commit address (derived from outputScript for the given network) */\n  address: string;\n  /** Estimated virtual size of the reveal transaction */\n  revealTransactionVSize: number;\n  /** Tap leaf script for spending the commit output */\n  tapLeafScript: TapLeafScript;\n};\n\n/**\n * BIP32-like interface compatible with both utxo-lib and wasm-utxo BIP32 types.\n * The publicKey can be Buffer (utxo-lib) or Uint8Array (wasm-utxo).\n */\nexport interface BIP32Like {\n  publicKey: Uint8Array;\n}\n\n/** Input type for inscription functions - either a BIP32-like key or raw public key bytes */\nexport type KeyInput = BIP32Like | Uint8Array;\n\nfunction isBIP32Like(key: KeyInput): key is BIP32Like {\n  return typeof key === 'object' && key !== null && 'publicKey' in key && !ArrayBuffer.isView(key);\n}\n\n/**\n * Extract compressed public key from key input.\n * Handles BIP32-like objects and raw pubkey bytes (32 or 33 bytes).\n */\nfunction getCompressedPublicKey(key: KeyInput): Uint8Array {\n  const pubkey = isBIP32Like(key) ? key.publicKey : key;\n\n  if (pubkey.length === 33) {\n    return pubkey;\n  }\n  if (pubkey.length === 32) {\n    // x-only pubkey - prepend 0x02 parity byte to make compressed\n    const compressedPubkey = new Uint8Array(33);\n    compressedPubkey[0] = 0x02;\n    compressedPubkey.set(pubkey, 1);\n    return compressedPubkey;\n  }\n  throw new Error(`Invalid public key length: ${pubkey.length}. Expected 32 or 33 bytes.`);\n}\n\n/**\n * Create the P2TR output script for an inscription.\n *\n * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)\n * @param contentType - MIME type of the inscription (e.g., \"text/plain\", \"image/png\")\n * @param inscriptionData - The inscription data bytes\n * @returns The P2TR output script for the inscription commit address\n */\nexport function createOutputScriptForInscription(\n  key: KeyInput,\n  contentType: string,\n  inscriptionData: Uint8Array\n): Uint8Array {\n  const compressedPubkey = getCompressedPublicKey(key);\n  const ecpair = ECPair.fromPublicKey(compressedPubkey);\n  const result = wasmInscriptions.createInscriptionRevealData(ecpair, contentType, inscriptionData);\n  return result.outputScript;\n}\n\n/**\n * Create inscription reveal data including the commit address and tap leaf script.\n *\n * @param key - BIP32 key or public key bytes (32-byte x-only or 33-byte compressed)\n * @param contentType - MIME type of the inscription (e.g., \"text/plain\", \"image/png\")\n * @param inscriptionData - The inscription data bytes\n * @param coinName - Coin name (e.g., \"btc\", \"tbtc\")\n * @returns PreparedInscriptionRevealData with address, vsize estimate, and tap leaf script\n */\nexport function createInscriptionRevealData(\n  key: KeyInput,\n  contentType: string,\n  inscriptionData: Uint8Array,\n  coinName: CoinName\n): PreparedInscriptionRevealData {\n  const compressedPubkey = getCompressedPublicKey(key);\n  const ecpair = ECPair.fromPublicKey(compressedPubkey);\n\n  const wasmResult = wasmInscriptions.createInscriptionRevealData(ecpair, contentType, inscriptionData);\n\n  // Convert outputScript to address for the given network\n  const address = wasmAddress.fromOutputScriptWithCoin(wasmResult.outputScript, coinName);\n\n  return {\n    address,\n    revealTransactionVSize: wasmResult.revealTransactionVSize,\n    tapLeafScript: wasmResult.tapLeafScript,\n  };\n}\n\n/**\n * Sign a reveal transaction.\n *\n * Creates and signs the reveal transaction that spends from the commit output\n * and sends the inscription to the recipient.\n *\n * @param privateKey - 32-byte private key\n * @param tapLeafScript - The tap leaf script from createInscriptionRevealData\n * @param commitAddress - The commit address\n * @param recipientAddress - Where to send the inscription\n * @param unsignedCommitTx - The unsigned commit transaction bytes\n * @param coinName - Coin name (e.g., \"btc\", \"tbtc\")\n * @returns The signed PSBT as bytes\n */\nexport function signRevealTransaction(\n  privateKey: Uint8Array,\n  tapLeafScript: TapLeafScript,\n  commitAddress: string,\n  recipientAddress: string,\n  unsignedCommitTx: Uint8Array,\n  coinName: CoinName\n): Uint8Array {\n  const ecpair = ECPair.fromPrivateKey(privateKey);\n  const commitTx = Transaction.fromBytes(unsignedCommitTx);\n  const commitOutputScript = wasmAddress.toOutputScriptWithCoin(commitAddress, coinName);\n  const recipientOutputScript = wasmAddress.toOutputScriptWithCoin(recipientAddress, coinName);\n\n  return wasmInscriptions.signRevealTransaction(\n    ecpair,\n    tapLeafScript,\n    commitTx,\n    commitOutputScript,\n    recipientOutputScript,\n    DEFAULT_POSTAGE_SATS\n  );\n}\n"]}

package/dist/esm/psbt.d.ts

@@ -0,0 +1,84 @@
+import { fixedScriptWallet, type CoinName } from '@bitgo/wasm-utxo';
+import { SatPoint } from './SatPoint';
+import { OutputLayout } from './OutputLayout';
+type WalletKeysArg = fixedScriptWallet.WalletKeysArg;
+type SignPath = fixedScriptWallet.SignPath;
+/**
+ * Network type from utxo-lib for backward compatibility.
+ */
+type UtxolibNetwork = {
+    messagePrefix?: string;
+    bech32?: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+};
+export type WalletUnspent = {
+    id: string;
+    value: bigint;
+    chain: number;
+    index: number;
+};
+export type WalletOutputPath = {
+    chain: fixedScriptWallet.ChainCode;
+    index: number;
+};
+export type WalletInputBuilder = {
+    walletKeys: WalletKeysArg;
+    signer: SignPath['signer'];
+    cosigner: SignPath['cosigner'];
+};
+/**
+ * Describes all outputs of an inscription transaction
+ */
+export type InscriptionTransactionOutputs = {
+    inscriptionRecipient: string | Uint8Array;
+    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(networkOrCoinName: CoinName | UtxolibNetwork, inputBuilder: WalletInputBuilder, unspents: WalletUnspent[], outputs: InscriptionTransactionOutputs, outputLayout: OutputLayout): fixedScriptWallet.BitGoPsbt;
+/**
+ * @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 networkOrCoinName - Coin name (e.g., "btc", "tbtc") or utxo-lib Network object
+ * @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(networkOrCoinName: CoinName | UtxolibNetwork, inputBuilder: WalletInputBuilder, unspent: WalletUnspent | WalletUnspent[], satPoint: SatPoint, outputs: InscriptionTransactionOutputs, constraints: InscriptionTransactionConstraints, { supplementaryUnspents, minimizeInputs, }?: {
+    supplementaryUnspents?: WalletUnspent[];
+    minimizeInputs?: boolean;
+}): fixedScriptWallet.BitGoPsbt;
+export {};
+//# sourceMappingURL=psbt.d.ts.map

package/dist/esm/psbt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psbt.d.ts","sourceRoot":"","sources":["../../src/psbt.ts"],"names":[],"mappings":"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"}

package/dist/esm/psbt.js

@@ -0,0 +1,186 @@
+import { fixedScriptWallet, Dimensions } from '@bitgo/wasm-utxo';
+import { OrdOutput } from './OrdOutput';
+import { parseSatPoint, parseOutputId } from './SatPoint';
+import { SatRange } from './SatRange';
+import { getOrdOutputsForLayout, toArray, findOutputLayout } from './OutputLayout';
+import { powerset } from './combinations';
+const { BitGoPsbt, ChainCode } = fixedScriptWallet;
+/**
+ * Map utxo-lib network objects to CoinName strings.
+ */
+function networkToCoinName(network) {
+    // Bitcoin mainnet
+    if (network.bech32 === 'bc' && network.pubKeyHash === 0) {
+        return 'btc';
+    }
+    // Bitcoin testnet
+    if (network.bech32 === 'tb' && network.pubKeyHash === 111) {
+        return 'tbtc';
+    }
+    throw new Error(`Unknown network: ${JSON.stringify(network)}`);
+}
+/**
+ * Normalize network parameter - accepts either CoinName string or utxo-lib Network object.
+ */
+function normalizeCoinName(networkOrCoinName) {
+    if (typeof networkOrCoinName === 'string') {
+        return networkOrCoinName;
+    }
+    return networkToCoinName(networkOrCoinName);
+}
+/** Segwit transaction overhead in virtual bytes */
+const TX_SEGWIT_OVERHEAD_VSIZE = 10;
+export const DefaultInscriptionConstraints = {
+    minChangeOutput: BigInt(10000),
+    minInscriptionOutput: BigInt(10000),
+    maxInscriptionOutput: BigInt(20000),
+};
+export function createPsbtFromOutputLayout(networkOrCoinName, inputBuilder, unspents, outputs, outputLayout) {
+    if (unspents.length === 0) {
+        throw new Error(`must provide at least one unspent`);
+    }
+    const coinName = normalizeCoinName(networkOrCoinName);
+    const psbt = BitGoPsbt.createEmpty(coinName, inputBuilder.walletKeys);
+    // Add inputs
+    unspents.forEach((u) => {
+        const { txid, vout } = parseOutputId(u.id);
+        psbt.addWalletInput({ txid, vout, value: u.value }, inputBuilder.walletKeys, {
+            scriptId: { chain: u.chain, index: u.index },
+            signPath: { signer: inputBuilder.signer, cosigner: inputBuilder.cosigner },
+        });
+    });
+    // Build ord outputs from layout
+    const ordInput = OrdOutput.joinAll(unspents.map((u) => new OrdOutput(u.value)));
+    const ordOutputs = getOrdOutputsForLayout(ordInput, outputLayout);
+    toArray(ordOutputs).forEach((ordOutput) => {
+        if (ordOutput === null) {
+            return;
+        }
+        switch (ordOutput) {
+            // skip fee output (virtual)
+            case ordOutputs.feeOutput:
+                return;
+            // add padding/change outputs
+            case ordOutputs.firstChangeOutput:
+            case ordOutputs.secondChangeOutput:
+                const { chain, index } = ordOutput === ordOutputs.firstChangeOutput ? outputs.changeOutputs[0] : outputs.changeOutputs[1];
+                psbt.addWalletOutput(inputBuilder.walletKeys, { chain, index, value: ordOutput.value });
+                break;
+            // add actual inscription output
+            case ordOutputs.inscriptionOutput:
+                const recipient = outputs.inscriptionRecipient;
+                if (typeof recipient === 'string') {
+                    psbt.addOutput(recipient, ordOutput.value);
+                }
+                else if (recipient instanceof Uint8Array) {
+                    psbt.addOutput(recipient, ordOutput.value);
+                }
+                else {
+                    throw new Error('inscriptionRecipient must be a string or Uint8Array');
+                }
+                break;
+        }
+    });
+    return psbt;
+}
+function toSatRange(p) {
+    const { offset } = parseSatPoint(p);
+    return new SatRange(offset, offset);
+}
+function getFee(vsize, rateSatPerKB) {
+    return BigInt(Math.ceil((vsize * rateSatPerKB) / 1000));
+}
+/**
+ * @param inputs - inscription input must come first
+ * @param satPoint - location of the inscription
+ * @param outputs
+ * @param constraints
+ * @param minimizeInputs
+ */
+export function findOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints, { minimizeInputs = false } = {}) {
+    if (minimizeInputs) {
+        return findSmallestOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints);
+    }
+    if (inputs.length === 0) {
+        throw new Error(`must provide at least one input`);
+    }
+    if (outputs.changeOutputs[0].chain !== outputs.changeOutputs[1].chain) {
+        // otherwise our fee calc is too complicated
+        throw new Error(`wallet outputs must be on same chain`);
+    }
+    const { minChangeOutput = DefaultInscriptionConstraints.minChangeOutput, minInscriptionOutput = DefaultInscriptionConstraints.minInscriptionOutput, maxInscriptionOutput = DefaultInscriptionConstraints.maxInscriptionOutput, } = constraints;
+    // Calculate input vsize using wasm-utxo Dimensions
+    const inputDimensions = inputs.reduce((dims, input) => dims.plus(Dimensions.fromInput({ chain: input.chain })), Dimensions.empty());
+    const inputsVSize = inputDimensions.getInputVSize();
+    // Calculate output vsize using wasm-utxo Dimensions
+    const outputDimensions = Dimensions.fromOutput({
+        scriptType: ChainCode.scriptType(outputs.changeOutputs[0].chain),
+    });
+    const outputVSize = outputDimensions.getOutputVSize();
+    // Join all the inputs into a single inscriptionOutput.
+    // For the purposes of finding a layout there is no difference.
+    const inscriptionOutput = OrdOutput.joinAll(inputs.map((i) => new OrdOutput(i.value, i === inputs[0] ? [toSatRange(satPoint)] : [])));
+    const layout = findOutputLayout(inscriptionOutput, {
+        minChangeOutput,
+        minInscriptionOutput,
+        maxInscriptionOutput,
+        feeFixed: getFee(TX_SEGWIT_OVERHEAD_VSIZE + inputsVSize, constraints.feeRateSatKB),
+        feePerOutput: getFee(outputVSize, constraints.feeRateSatKB),
+    });
+    return layout ? { inputs, layout } : undefined;
+}
+export const MAX_UNSPENTS_FOR_OUTPUT_LAYOUT = 5;
+/**
+ * @param inputs - inscription input must come first
+ * @param satPoint - location of the inscription
+ * @param outputs
+ * @param constraints
+ */
+function findSmallestOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints) {
+    if (MAX_UNSPENTS_FOR_OUTPUT_LAYOUT < inputs.length) {
+        throw new Error(`input array is too large`);
+    }
+    // create powerset of all supplementary inputs and find the cheapest result
+    const inputsArr = [inputs, ...powerset(inputs.slice(1)).map((s) => [inputs[0], ...s])];
+    return inputsArr
+        .map((inputs) => findOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints))
+        .reduce((best, next) => {
+        if (best === undefined) {
+            return next;
+        }
+        if (next === undefined) {
+            return best;
+        }
+        return best.layout.feeOutput < next.layout.feeOutput ? best : next;
+    });
+}
+export class ErrorNoLayout extends Error {
+    constructor() {
+        super('Could not find output layout for inscription passing transaction');
+    }
+}
+/**
+ * @param networkOrCoinName - Coin name (e.g., "btc", "tbtc") or utxo-lib Network object
+ * @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 function createPsbtForSingleInscriptionPassingTransaction(networkOrCoinName, inputBuilder, unspent, satPoint, outputs, constraints, { supplementaryUnspents = [], minimizeInputs = true, } = {}) {
+    // support for legacy call style
+    if (Array.isArray(unspent)) {
+        if (unspent.length !== 1) {
+            throw new Error(`can only pass single unspent`);
+        }
+        unspent = unspent[0];
+    }
+    const result = findOutputLayoutForWalletUnspents([unspent, ...supplementaryUnspents], satPoint, outputs, constraints, { minimizeInputs });
+    if (!result) {
+        throw new ErrorNoLayout();
+    }
+    return createPsbtFromOutputLayout(networkOrCoinName, inputBuilder, result.inputs, outputs, result.layout);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"psbt.js","sourceRoot":"","sources":["../../src/psbt.ts"],"names":[],"mappings":"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","sourcesContent":["import { fixedScriptWallet, Dimensions, type CoinName } from '@bitgo/wasm-utxo';\n\nimport { OrdOutput } from './OrdOutput';\nimport { parseSatPoint, parseOutputId, SatPoint } from './SatPoint';\nimport { SatRange } from './SatRange';\nimport { getOrdOutputsForLayout, OutputLayout, toArray, findOutputLayout } from './OutputLayout';\nimport { powerset } from './combinations';\n\ntype WalletKeysArg = fixedScriptWallet.WalletKeysArg;\ntype SignPath = fixedScriptWallet.SignPath;\nconst { BitGoPsbt, ChainCode } = fixedScriptWallet;\n\n/**\n * Network type from utxo-lib for backward compatibility.\n */\ntype UtxolibNetwork = {\n  messagePrefix?: string;\n  bech32?: string;\n  pubKeyHash: number;\n  scriptHash: number;\n  wif: number;\n};\n\n/**\n * Map utxo-lib network objects to CoinName strings.\n */\nfunction networkToCoinName(network: UtxolibNetwork): CoinName {\n  // Bitcoin mainnet\n  if (network.bech32 === 'bc' && network.pubKeyHash === 0) {\n    return 'btc';\n  }\n  // Bitcoin testnet\n  if (network.bech32 === 'tb' && network.pubKeyHash === 111) {\n    return 'tbtc';\n  }\n  throw new Error(`Unknown network: ${JSON.stringify(network)}`);\n}\n\n/**\n * Normalize network parameter - accepts either CoinName string or utxo-lib Network object.\n */\nfunction normalizeCoinName(networkOrCoinName: CoinName | UtxolibNetwork): CoinName {\n  if (typeof networkOrCoinName === 'string') {\n    return networkOrCoinName;\n  }\n  return networkToCoinName(networkOrCoinName);\n}\n\n/** Segwit transaction overhead in virtual bytes */\nconst TX_SEGWIT_OVERHEAD_VSIZE = 10;\n\nexport type WalletUnspent = {\n  id: string; // \"txid:vout\"\n  value: bigint;\n  chain: number;\n  index: number;\n};\n\nexport type WalletOutputPath = {\n  chain: fixedScriptWallet.ChainCode;\n  index: number;\n};\n\nexport type WalletInputBuilder = {\n  walletKeys: WalletKeysArg;\n  signer: SignPath['signer'];\n  cosigner: SignPath['cosigner'];\n};\n\n/**\n * Describes all outputs of an inscription transaction\n */\nexport type InscriptionTransactionOutputs = {\n  inscriptionRecipient: string | Uint8Array;\n  changeOutputs: [WalletOutputPath, WalletOutputPath];\n};\n\n/** @deprecated */\nexport type InscriptionOutputs = InscriptionTransactionOutputs;\n\nexport type InscriptionTransactionConstraints = {\n  feeRateSatKB: number;\n  minChangeOutput?: bigint;\n  minInscriptionOutput?: bigint;\n  maxInscriptionOutput?: bigint;\n};\n\nexport const DefaultInscriptionConstraints = {\n  minChangeOutput: BigInt(10_000),\n  minInscriptionOutput: BigInt(10_000),\n  maxInscriptionOutput: BigInt(20_000),\n};\n\nexport function createPsbtFromOutputLayout(\n  networkOrCoinName: CoinName | UtxolibNetwork,\n  inputBuilder: WalletInputBuilder,\n  unspents: WalletUnspent[],\n  outputs: InscriptionTransactionOutputs,\n  outputLayout: OutputLayout\n): fixedScriptWallet.BitGoPsbt {\n  if (unspents.length === 0) {\n    throw new Error(`must provide at least one unspent`);\n  }\n\n  const coinName = normalizeCoinName(networkOrCoinName);\n  const psbt = BitGoPsbt.createEmpty(coinName, inputBuilder.walletKeys);\n\n  // Add inputs\n  unspents.forEach((u) => {\n    const { txid, vout } = parseOutputId(u.id);\n    psbt.addWalletInput({ txid, vout, value: u.value }, inputBuilder.walletKeys, {\n      scriptId: { chain: u.chain, index: u.index },\n      signPath: { signer: inputBuilder.signer, cosigner: inputBuilder.cosigner },\n    });\n  });\n\n  // Build ord outputs from layout\n  const ordInput = OrdOutput.joinAll(unspents.map((u) => new OrdOutput(u.value)));\n  const ordOutputs = getOrdOutputsForLayout(ordInput, outputLayout);\n\n  toArray(ordOutputs).forEach((ordOutput) => {\n    if (ordOutput === null) {\n      return;\n    }\n    switch (ordOutput) {\n      // skip fee output (virtual)\n      case ordOutputs.feeOutput:\n        return;\n      // add padding/change outputs\n      case ordOutputs.firstChangeOutput:\n      case ordOutputs.secondChangeOutput:\n        const { chain, index } =\n          ordOutput === ordOutputs.firstChangeOutput ? outputs.changeOutputs[0] : outputs.changeOutputs[1];\n        psbt.addWalletOutput(inputBuilder.walletKeys, { chain, index, value: ordOutput.value });\n        break;\n      // add actual inscription output\n      case ordOutputs.inscriptionOutput:\n        const recipient = outputs.inscriptionRecipient;\n        if (typeof recipient === 'string') {\n          psbt.addOutput(recipient, ordOutput.value);\n        } else if (recipient instanceof Uint8Array) {\n          psbt.addOutput(recipient, ordOutput.value);\n        } else {\n          throw new Error('inscriptionRecipient must be a string or Uint8Array');\n        }\n        break;\n    }\n  });\n\n  return psbt;\n}\n\nfunction toSatRange(p: SatPoint) {\n  const { offset } = parseSatPoint(p);\n  return new SatRange(offset, offset);\n}\n\nfunction getFee(vsize: number, rateSatPerKB: number): bigint {\n  return BigInt(Math.ceil((vsize * rateSatPerKB) / 1000));\n}\n\n/**\n * @param inputs - inscription input must come first\n * @param satPoint - location of the inscription\n * @param outputs\n * @param constraints\n * @param minimizeInputs\n */\nexport function findOutputLayoutForWalletUnspents(\n  inputs: WalletUnspent[],\n  satPoint: SatPoint,\n  outputs: InscriptionTransactionOutputs,\n  constraints: InscriptionTransactionConstraints,\n  { minimizeInputs = false } = {}\n): { inputs: WalletUnspent[]; layout: OutputLayout } | undefined {\n  if (minimizeInputs) {\n    return findSmallestOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints);\n  }\n\n  if (inputs.length === 0) {\n    throw new Error(`must provide at least one input`);\n  }\n\n  if (outputs.changeOutputs[0].chain !== outputs.changeOutputs[1].chain) {\n    // otherwise our fee calc is too complicated\n    throw new Error(`wallet outputs must be on same chain`);\n  }\n\n  const {\n    minChangeOutput = DefaultInscriptionConstraints.minChangeOutput,\n    minInscriptionOutput = DefaultInscriptionConstraints.minInscriptionOutput,\n    maxInscriptionOutput = DefaultInscriptionConstraints.maxInscriptionOutput,\n  } = constraints;\n\n  // Calculate input vsize using wasm-utxo Dimensions\n  const inputDimensions = inputs.reduce(\n    (dims, input) => dims.plus(Dimensions.fromInput({ chain: input.chain })),\n    Dimensions.empty()\n  );\n  const inputsVSize = inputDimensions.getInputVSize();\n\n  // Calculate output vsize using wasm-utxo Dimensions\n  const outputDimensions = Dimensions.fromOutput({\n    scriptType: ChainCode.scriptType(outputs.changeOutputs[0].chain),\n  });\n  const outputVSize = outputDimensions.getOutputVSize();\n\n  // Join all the inputs into a single inscriptionOutput.\n  // For the purposes of finding a layout there is no difference.\n  const inscriptionOutput = OrdOutput.joinAll(\n    inputs.map((i) => new OrdOutput(i.value, i === inputs[0] ? [toSatRange(satPoint)] : []))\n  );\n  const layout = findOutputLayout(inscriptionOutput, {\n    minChangeOutput,\n    minInscriptionOutput,\n    maxInscriptionOutput,\n    feeFixed: getFee(TX_SEGWIT_OVERHEAD_VSIZE + inputsVSize, constraints.feeRateSatKB),\n    feePerOutput: getFee(outputVSize, constraints.feeRateSatKB),\n  });\n\n  return layout ? { inputs, layout } : undefined;\n}\n\nexport const MAX_UNSPENTS_FOR_OUTPUT_LAYOUT = 5;\n\n/**\n * @param inputs - inscription input must come first\n * @param satPoint - location of the inscription\n * @param outputs\n * @param constraints\n */\nfunction findSmallestOutputLayoutForWalletUnspents(\n  inputs: WalletUnspent[],\n  satPoint: SatPoint,\n  outputs: InscriptionTransactionOutputs,\n  constraints: InscriptionTransactionConstraints\n): { inputs: WalletUnspent[]; layout: OutputLayout } | undefined {\n  if (MAX_UNSPENTS_FOR_OUTPUT_LAYOUT < inputs.length) {\n    throw new Error(`input array is too large`);\n  }\n  // create powerset of all supplementary inputs and find the cheapest result\n  const inputsArr = [inputs, ...powerset(inputs.slice(1)).map((s) => [inputs[0], ...s])];\n  return inputsArr\n    .map((inputs) => findOutputLayoutForWalletUnspents(inputs, satPoint, outputs, constraints))\n    .reduce((best, next) => {\n      if (best === undefined) {\n        return next;\n      }\n      if (next === undefined) {\n        return best;\n      }\n      return best.layout.feeOutput < next.layout.feeOutput ? best : next;\n    });\n}\n\nexport class ErrorNoLayout extends Error {\n  constructor() {\n    super('Could not find output layout for inscription passing transaction');\n  }\n}\n\n/**\n * @param networkOrCoinName - Coin name (e.g., \"btc\", \"tbtc\") or utxo-lib Network object\n * @param inputBuilder\n * @param unspent\n * @param satPoint\n * @param outputs\n * @param constraints\n * @param supplementaryUnspents - additional inputs to cover fee.\n * @param [minimizeInputs=true] - try to find input combination with minimal fees. Limits supplementaryUnspents to 4.\n */\nexport function createPsbtForSingleInscriptionPassingTransaction(\n  networkOrCoinName: CoinName | UtxolibNetwork,\n  inputBuilder: WalletInputBuilder,\n  unspent: WalletUnspent | WalletUnspent[],\n  satPoint: SatPoint,\n  outputs: InscriptionTransactionOutputs,\n  constraints: InscriptionTransactionConstraints,\n  {\n    supplementaryUnspents = [],\n    minimizeInputs = true,\n  }: {\n    supplementaryUnspents?: WalletUnspent[];\n    minimizeInputs?: boolean;\n  } = {}\n): fixedScriptWallet.BitGoPsbt {\n  // support for legacy call style\n  if (Array.isArray(unspent)) {\n    if (unspent.length !== 1) {\n      throw new Error(`can only pass single unspent`);\n    }\n    unspent = unspent[0];\n  }\n\n  const result = findOutputLayoutForWalletUnspents(\n    [unspent, ...supplementaryUnspents],\n    satPoint,\n    outputs,\n    constraints,\n    { minimizeInputs }\n  );\n\n  if (!result) {\n    throw new ErrorNoLayout();\n  }\n\n  return createPsbtFromOutputLayout(networkOrCoinName, inputBuilder, result.inputs, outputs, result.layout);\n}\n"]}