utxo-lib 1.0.1

package/dist/src/bitgo/parseInput.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePubScript = exports.parseSignatureScript2Of3 = exports.parseSignatureScript = exports.getScriptPathLevel = exports.calculateScriptPathLevel = exports.isValidControlBock = exports.isPlaceholderSignature = void 0;
+const opcodes = require("bitcoin-ops");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const outputScripts_1 = require("./outputScripts");
+const types_1 = require("./types");
+function isPlaceholderSignature(v) {
+    if (Buffer.isBuffer(v)) {
+        return v.length === 0;
+    }
+    return v === 0;
+}
+exports.isPlaceholderSignature = isPlaceholderSignature;
+/**
+ * @return true iff P2TR script path's control block matches BitGo's need
+ */
+function isValidControlBock(controlBlock) {
+    // The last stack element is called the control block c, and must have length 33 + 32m
+    return Buffer.isBuffer(controlBlock) && 33 <= controlBlock.length && controlBlock.length % 32 === 1;
+}
+exports.isValidControlBock = isValidControlBock;
+/**
+ * @return script path level for P2TR control block
+ */
+function calculateScriptPathLevel(controlBlock) {
+    if (!Buffer.isBuffer(controlBlock)) {
+        throw new Error('Invalid control block type.');
+    }
+    if (controlBlock.length === 65) {
+        return 1;
+    }
+    if (controlBlock.length === 97) {
+        return 2;
+    }
+    throw new Error('unexpected control block length.');
+}
+exports.calculateScriptPathLevel = calculateScriptPathLevel;
+/**
+ * @return leaf version for P2TR control block.
+ */
+function getScriptPathLevel(controlBlock) {
+    if (Buffer.isBuffer(controlBlock) && controlBlock.length > 0) {
+        return controlBlock[0] & 0xfe;
+    }
+    throw new Error('unexpected leafVersion.');
+}
+exports.getScriptPathLevel = getScriptPathLevel;
+function emptyMatchResult() {
+    return {
+        ':pubkey': [],
+        ':pubkey-xonly': [],
+        ':control-block': [],
+        ':signature': [],
+        ':script': [],
+    };
+}
+class MatchError extends Error {
+    constructor(message) {
+        super(message);
+        // this property is required to prohibit `return new Error()` when the return type demands `MatchError`
+        this.__type = 'MatchError';
+    }
+    static forPatternElement(p) {
+        if (typeof p === 'object' && ':script' in p) {
+            return new MatchError(`error matching nested script`);
+        }
+        return new MatchError(`error matching ${p}`);
+    }
+}
+/**
+ * @param script
+ * @param pattern
+ * @return MatchResult if script matches pattern. The result will contain the matched values.
+ */
+function matchScript(script, pattern) {
+    /**
+     * Match a single script element with a ScriptPatternElement
+     */
+    function matchElement(e, p) {
+        switch (p) {
+            case 'OP_0':
+                return e === opcodes.OP_0 || (Buffer.isBuffer(e) && e.length === 0);
+            case 'OP_1':
+            case 'OP_2':
+            case 'OP_3':
+            case 'OP_CHECKMULTISIG':
+            case 'OP_CHECKSIG':
+            case 'OP_CHECKSIGVERIFY':
+                return e === opcodes[p];
+            case ':pubkey':
+                return Buffer.isBuffer(e) && e.length === 33;
+            case ':pubkey-xonly':
+                return Buffer.isBuffer(e) && e.length === 32;
+            case ':signature':
+                return Buffer.isBuffer(e) || isPlaceholderSignature(e);
+            case ':control-block':
+                return Buffer.isBuffer(e) && isValidControlBock(e);
+            default:
+                throw new Error(`unknown pattern element ${p}`);
+        }
+    }
+    if (script.length !== pattern.length) {
+        return new MatchError(`length mismatch`);
+    }
+    // Go over each pattern element.
+    // Collect captures into a result object.
+    return pattern.reduce((obj, p, i) => {
+        // if we had a previous mismatch, short-circuit
+        if (obj instanceof MatchError) {
+            return obj;
+        }
+        const e = script[i];
+        // for ':script' pattern elements, decompile script element and recurse
+        if (typeof p === 'object' && ':script' in p) {
+            if (!Buffer.isBuffer(e)) {
+                return new MatchError(`expected buffer for :script`);
+            }
+            const dec = bitcoinjs_lib_1.script.decompile(e);
+            if (!dec) {
+                return new MatchError(`error decompiling nested script`);
+            }
+            const match = matchScript(dec, p[':script']);
+            if (match instanceof MatchError) {
+                return match;
+            }
+            obj[':script'].push({
+                buffer: e,
+                match,
+            });
+            return obj;
+        }
+        const match = matchElement(e, p);
+        if (!match) {
+            return MatchError.forPatternElement(p);
+        }
+        // if pattern element is a capture, add it to the result obj
+        if (p === ':signature' && e === 0) {
+            obj[p].push(e);
+        }
+        else if (p in obj) {
+            if (!Buffer.isBuffer(e)) {
+                throw new Error(`invalid capture value`);
+            }
+            obj[p].push(e);
+        }
+        return obj;
+    }, emptyMatchResult());
+}
+/**
+ * @param script
+ * @param patterns
+ * @return first match
+ */
+function matchScriptSome(script, patterns) {
+    for (const p of patterns) {
+        const m = matchScript(script, p);
+        if (m instanceof MatchError) {
+            continue;
+        }
+        return m;
+    }
+    return new MatchError(`no match for script`);
+}
+function isLegacy(p) {
+    return Boolean(p.script && !p.witness);
+}
+function isWrappedSegwit(p) {
+    return Boolean(p.script && p.witness);
+}
+function isNativeSegwit(p) {
+    return Boolean(!p.script && p.witness);
+}
+const parseP2shP2pk = (p) => {
+    if (!isLegacy(p)) {
+        return new MatchError(`expected legacy input`);
+    }
+    const match = matchScript(p.script, [':signature', { ':script': [':pubkey', 'OP_CHECKSIG'] }]);
+    if (match instanceof MatchError) {
+        return match;
+    }
+    return {
+        scriptType: 'p2shP2pk',
+        publicKeys: match[':script'][0].match[':pubkey'],
+        signatures: match[':signature'],
+    };
+};
+function parseP2ms(decScript, scriptType) {
+    const pattern2Of3 = ['OP_2', ':pubkey', ':pubkey', ':pubkey', 'OP_3', 'OP_CHECKMULTISIG'];
+    const match = matchScriptSome(decScript, [
+        /* full-signed, no placeholder signature */
+        ['OP_0', ':signature', ':signature', { ':script': pattern2Of3 }],
+        /* half-signed, placeholder signatures */
+        ['OP_0', ':signature', ':signature', ':signature', { ':script': pattern2Of3 }],
+    ]);
+    if (match instanceof MatchError) {
+        return match;
+    }
+    const [redeemScript] = match[':script'];
+    if (!types_1.isTriple(redeemScript.match[':pubkey'])) {
+        throw new Error(`invalid pubkey count`);
+    }
+    return {
+        scriptType,
+        publicKeys: redeemScript.match[':pubkey'],
+        pubScript: redeemScript.buffer,
+        signatures: match[':signature'],
+        redeemScript: scriptType === 'p2sh' ? redeemScript.buffer : undefined,
+        witnessScript: scriptType === 'p2shP2wsh' || scriptType === 'p2wsh' ? redeemScript.buffer : undefined,
+    };
+}
+const parseP2sh2Of3 = (p) => {
+    if (!isLegacy(p)) {
+        return new MatchError(`expected legacy input`);
+    }
+    return parseP2ms(p.script, 'p2sh');
+};
+const parseP2shP2wsh2Of3 = (p) => {
+    if (!isWrappedSegwit(p)) {
+        return new MatchError(`expected wrapped segwit input`);
+    }
+    return { ...parseP2ms(p.witness, 'p2shP2wsh'), redeemScript: p.script[0] };
+};
+const parseP2wsh2Of3 = (p) => {
+    if (!isNativeSegwit(p)) {
+        return new MatchError(`expected native segwit`);
+    }
+    return parseP2ms(p.witness, 'p2wsh');
+};
+const parseP2tr2Of3 = (p) => {
+    if (!isNativeSegwit(p)) {
+        return new MatchError(`expected native segwit`);
+    }
+    // assumes no annex
+    const match = matchScript(p.witness, [
+        ':signature',
+        ':signature',
+        { ':script': [':pubkey-xonly', 'OP_CHECKSIGVERIFY', ':pubkey-xonly', 'OP_CHECKSIG'] },
+        ':control-block',
+    ]);
+    if (match instanceof MatchError) {
+        return match;
+    }
+    const [controlBlock] = match[':control-block'];
+    const scriptPathLevel = calculateScriptPathLevel(controlBlock);
+    const leafVersion = getScriptPathLevel(controlBlock);
+    return {
+        scriptType: 'p2tr',
+        pubScript: match[':script'][0].buffer,
+        publicKeys: match[':script'][0].match[':pubkey-xonly'],
+        signatures: match[':signature'],
+        controlBlock,
+        scriptPathLevel,
+        leafVersion,
+    };
+};
+/**
+ * Parse a transaction's signature script to obtain public keys, signatures, the sig script,
+ * and other properties.
+ *
+ * Only supports script types used in BitGo transactions.
+ *
+ * @param input
+ * @returns ParsedSignatureScript
+ */
+function parseSignatureScript(input) {
+    const decScript = bitcoinjs_lib_1.script.decompile(input.script);
+    const parsers = [parseP2sh2Of3, parseP2shP2wsh2Of3, parseP2wsh2Of3, parseP2tr2Of3, parseP2shP2pk];
+    for (const f of parsers) {
+        const parsed = f({
+            script: (decScript === null || decScript === void 0 ? void 0 : decScript.length) === 0 ? null : decScript,
+            witness: input.witness.length === 0 ? null : input.witness,
+        });
+        if (parsed instanceof MatchError) {
+            continue;
+        }
+        return parsed;
+    }
+    throw new Error(`could not parse input`);
+}
+exports.parseSignatureScript = parseSignatureScript;
+function parseSignatureScript2Of3(input) {
+    const result = parseSignatureScript(input);
+    if (!outputScripts_1.isScriptType2Of3(result.scriptType)) {
+        throw new Error(`invalid script type`);
+    }
+    if (!result.signatures) {
+        throw new Error(`missing signatures`);
+    }
+    if (result.publicKeys.length !== 3 && (result.publicKeys.length !== 2 || result.scriptType !== 'p2tr')) {
+        throw new Error(`unexpected pubkey count`);
+    }
+    return result;
+}
+exports.parseSignatureScript2Of3 = parseSignatureScript2Of3;
+const parseP2msPubScript = (pubScript, scriptType) => {
+    const match = matchScript([pubScript], [{ ':script': ['OP_2', ':pubkey', ':pubkey', ':pubkey', 'OP_3', 'OP_CHECKMULTISIG'] }]);
+    if (match instanceof MatchError) {
+        return match;
+    }
+    const [redeemScript] = match[':script'];
+    if (!types_1.isTriple(redeemScript.match[':pubkey'])) {
+        throw new Error('invalid pubkey count');
+    }
+    return {
+        scriptType,
+        publicKeys: redeemScript.match[':pubkey'],
+        pubScript: redeemScript.buffer,
+        redeemScript: scriptType === 'p2sh' ? redeemScript.buffer : undefined,
+        witnessScript: scriptType === 'p2shP2wsh' || scriptType === 'p2wsh' ? redeemScript.buffer : undefined,
+    };
+};
+const parseP2tr2Of3PubScript = (pubScript, scriptType) => {
+    const match = matchScript([pubScript], [{ ':script': [':pubkey-xonly', 'OP_CHECKSIGVERIFY', ':pubkey-xonly', 'OP_CHECKSIG'] }]);
+    if (match instanceof MatchError) {
+        return match;
+    }
+    return {
+        scriptType: 'p2tr',
+        pubScript: match[':script'][0].buffer,
+        publicKeys: match[':script'][0].match[':pubkey-xonly'],
+    };
+};
+/**
+ * @return pubScript (scriptPubKey/redeemScript/witnessScript) is parsed.
+ * P2SH => scriptType, pubScript (redeemScript), redeemScript, public keys
+ * PW2SH => scriptType, pubScript (witnessScript), witnessScript, public keys.
+ * P2SH-PW2SH => scriptType, pubScript (witnessScript), witnessScript, public keys.
+ * P2TR => scriptType, pubScript, controlBlock, scriptPathLevel, leafVersion, pub keys, signatures.
+ */
+function parsePubScript(inputPubScript, scriptType) {
+    const result = scriptType === 'p2tr'
+        ? parseP2tr2Of3PubScript(inputPubScript, scriptType)
+        : parseP2msPubScript(inputPubScript, scriptType);
+    if (result instanceof MatchError) {
+        throw new Error(result.message);
+    }
+    if (result.publicKeys.length !== 3 && (result.publicKeys.length !== 2 || result.scriptType !== 'p2tr')) {
+        throw new Error('unexpected pubkey count');
+    }
+    return result;
+}
+exports.parsePubScript = parsePubScript;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parseInput.js","sourceRoot":"","sources":["../../../src/bitgo/parseInput.ts"],"names":[],"mappings":"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","sourcesContent":["import * as opcodes from 'bitcoin-ops';\nimport { TxInput, script as bscript } from 'bitcoinjs-lib';\n\nimport { isScriptType2Of3, ScriptType, ScriptType2Of3 } from './outputScripts';\nimport { isTriple } from './types';\n\nexport function isPlaceholderSignature(v: number | Buffer): boolean {\n  if (Buffer.isBuffer(v)) {\n    return v.length === 0;\n  }\n  return v === 0;\n}\n\n/**\n * @return true iff P2TR script path's control block matches BitGo's need\n */\nexport function isValidControlBock(controlBlock: Buffer): boolean {\n  // The last stack element is called the control block c, and must have length 33 + 32m\n  return Buffer.isBuffer(controlBlock) && 33 <= controlBlock.length && controlBlock.length % 32 === 1;\n}\n\n/**\n * @return script path level for P2TR control block\n */\nexport function calculateScriptPathLevel(controlBlock: Buffer): number {\n  if (!Buffer.isBuffer(controlBlock)) {\n    throw new Error('Invalid control block type.');\n  }\n  if (controlBlock.length === 65) {\n    return 1;\n  }\n  if (controlBlock.length === 97) {\n    return 2;\n  }\n  throw new Error('unexpected control block length.');\n}\n\n/**\n * @return leaf version for P2TR control block.\n */\nexport function getScriptPathLevel(controlBlock: Buffer): number {\n  if (Buffer.isBuffer(controlBlock) && controlBlock.length > 0) {\n    return controlBlock[0] & 0xfe;\n  }\n  throw new Error('unexpected leafVersion.');\n}\n\ninterface ParsedScript {\n  scriptType: ScriptType;\n}\n\nexport type ParsedPubScript = ParsedScript;\nexport type ParsedSignatureScript = ParsedScript;\n\nexport interface ParsedSignatureScriptP2shP2pk extends ParsedSignatureScript {\n  scriptType: 'p2shP2pk';\n  publicKeys: [Buffer];\n  signatures: [Buffer];\n}\n\nexport interface ParsedPubScriptTaprootScriptPath extends ParsedPubScript {\n  scriptType: 'p2tr';\n  publicKeys: [Buffer, Buffer];\n  pubScript: Buffer;\n}\n\nexport interface ParsedPubScript2Of3 extends ParsedPubScript {\n  scriptType: 'p2sh' | 'p2shP2wsh' | 'p2wsh';\n  publicKeys: [Buffer, Buffer, Buffer];\n  pubScript: Buffer;\n  redeemScript: Buffer | undefined;\n  witnessScript: Buffer | undefined;\n}\n\nexport interface ParsedSignatureScript2Of3 extends ParsedSignatureScript {\n  scriptType: 'p2sh' | 'p2shP2wsh' | 'p2wsh';\n  publicKeys: [Buffer, Buffer, Buffer];\n  signatures:\n    | [Buffer, Buffer] // fully-signed transactions with signatures\n    /* Partially signed transactions with placeholder signatures.\n       For p2sh, the placeholder is OP_0 (number 0) */\n    | [Buffer | 0, Buffer | 0, Buffer | 0];\n  pubScript: Buffer;\n  redeemScript: Buffer | undefined;\n  witnessScript: Buffer | undefined;\n}\n\n/**\n * Keypath spends only have a single pubkey and single signature\n */\nexport interface ParsedSignatureScriptTaprootKeyPath extends ParsedSignatureScript {\n  scriptType: 'p2tr';\n  publicKeys: [Buffer];\n  signatures: [Buffer];\n  pubScript: Buffer;\n}\n\n/**\n * Taproot Scriptpath spends are more similar to regular p2ms spends and have two public keys and\n * two signatures\n */\nexport interface ParsedSignatureScriptTaprootScriptPath extends ParsedSignatureScript {\n  scriptType: 'p2tr';\n  publicKeys: [Buffer, Buffer];\n  signatures: [Buffer, Buffer];\n  controlBlock: Buffer;\n  leafVersion: number;\n  /** Indicates the level inside the taptree. */\n  scriptPathLevel: number;\n  pubScript: Buffer;\n}\n\nexport type ParsedSignatureScriptTaproot = ParsedSignatureScriptTaprootKeyPath | ParsedSignatureScriptTaprootScriptPath;\n\ntype DecompiledScript = Array<Buffer | number>;\n\n/**\n * Static script elements\n */\ntype ScriptPatternConstant =\n  | 'OP_0'\n  | 'OP_1'\n  | 'OP_2'\n  | 'OP_3'\n  | 'OP_CHECKMULTISIG'\n  | 'OP_CHECKSIG'\n  | 'OP_CHECKSIGVERIFY';\n\n/**\n * Script elements that can be captured\n */\ntype ScriptPatternCapture =\n  | ':pubkey'\n  | ':pubkey-xonly'\n  | ':signature'\n  | ':control-block'\n  | { ':script': ScriptPatternElement[] };\n\ntype ScriptPatternElement = ScriptPatternConstant | ScriptPatternCapture;\n\n/**\n * Result for a successful script match\n */\ntype MatchResult = {\n  ':pubkey': Buffer[];\n  ':pubkey-xonly': Buffer[];\n  ':control-block': Buffer[];\n  ':signature': (Buffer | 0)[];\n  ':script': { buffer: Buffer; match: MatchResult }[];\n};\n\nfunction emptyMatchResult(): MatchResult {\n  return {\n    ':pubkey': [],\n    ':pubkey-xonly': [],\n    ':control-block': [],\n    ':signature': [],\n    ':script': [],\n  };\n}\n\nclass MatchError extends Error {\n  // this property is required to prohibit `return new Error()` when the return type demands `MatchError`\n  __type = 'MatchError';\n  constructor(message: string) {\n    super(message);\n  }\n\n  static forPatternElement(p: ScriptPatternElement): MatchError {\n    if (typeof p === 'object' && ':script' in p) {\n      return new MatchError(`error matching nested script`);\n    }\n    return new MatchError(`error matching ${p}`);\n  }\n}\n\n/**\n * @param script\n * @param pattern\n * @return MatchResult if script matches pattern. The result will contain the matched values.\n */\nfunction matchScript(script: DecompiledScript, pattern: ScriptPatternElement[]): MatchResult | MatchError {\n  /**\n   * Match a single script element with a ScriptPatternElement\n   */\n  function matchElement(e: Buffer | number, p: ScriptPatternElement): MatchResult | boolean {\n    switch (p) {\n      case 'OP_0':\n        return e === opcodes.OP_0 || (Buffer.isBuffer(e) && e.length === 0);\n      case 'OP_1':\n      case 'OP_2':\n      case 'OP_3':\n      case 'OP_CHECKMULTISIG':\n      case 'OP_CHECKSIG':\n      case 'OP_CHECKSIGVERIFY':\n        return e === opcodes[p];\n      case ':pubkey':\n        return Buffer.isBuffer(e) && e.length === 33;\n      case ':pubkey-xonly':\n        return Buffer.isBuffer(e) && e.length === 32;\n      case ':signature':\n        return Buffer.isBuffer(e) || isPlaceholderSignature(e);\n      case ':control-block':\n        return Buffer.isBuffer(e) && isValidControlBock(e);\n      default:\n        throw new Error(`unknown pattern element ${p}`);\n    }\n  }\n\n  if (script.length !== pattern.length) {\n    return new MatchError(`length mismatch`);\n  }\n\n  // Go over each pattern element.\n  // Collect captures into a result object.\n  return pattern.reduce((obj: MatchResult | MatchError, p, i): MatchResult | MatchError => {\n    // if we had a previous mismatch, short-circuit\n    if (obj instanceof MatchError) {\n      return obj;\n    }\n\n    const e = script[i];\n\n    // for ':script' pattern elements, decompile script element and recurse\n    if (typeof p === 'object' && ':script' in p) {\n      if (!Buffer.isBuffer(e)) {\n        return new MatchError(`expected buffer for :script`);\n      }\n      const dec = bscript.decompile(e);\n      if (!dec) {\n        return new MatchError(`error decompiling nested script`);\n      }\n      const match = matchScript(dec, p[':script']);\n      if (match instanceof MatchError) {\n        return match;\n      }\n      obj[':script'].push({\n        buffer: e,\n        match,\n      });\n      return obj;\n    }\n\n    const match = matchElement(e, p);\n    if (!match) {\n      return MatchError.forPatternElement(p);\n    }\n\n    // if pattern element is a capture, add it to the result obj\n    if (p === ':signature' && e === 0) {\n      obj[p].push(e);\n    } else if (p in obj) {\n      if (!Buffer.isBuffer(e)) {\n        throw new Error(`invalid capture value`);\n      }\n      obj[p].push(e);\n    }\n\n    return obj;\n  }, emptyMatchResult());\n}\n\n/**\n * @param script\n * @param patterns\n * @return first match\n */\nfunction matchScriptSome(script: DecompiledScript, patterns: ScriptPatternElement[][]): MatchResult | MatchError {\n  for (const p of patterns) {\n    const m = matchScript(script, p);\n    if (m instanceof MatchError) {\n      continue;\n    }\n    return m;\n  }\n  return new MatchError(`no match for script`);\n}\n\ntype InputScripts<TScript, TWitness> = {\n  script: TScript;\n  witness: TWitness;\n};\n\ntype InputScriptsLegacy = InputScripts<DecompiledScript, null>;\ntype InputScriptsWrappedSegwit = InputScripts<DecompiledScript, Buffer[]>;\ntype InputScriptsNativeSegwit = InputScripts<null, Buffer[]>;\n\ntype InputScriptsUnknown = InputScripts<DecompiledScript | null, Buffer[] | null>;\n\ntype InputParser<T extends ParsedSignatureScriptP2shP2pk | ParsedSignatureScript2Of3 | ParsedSignatureScriptTaproot> = (\n  p: InputScriptsUnknown\n) => T | MatchError;\n\nexport type InputPubScript = Buffer;\n\ntype PubScriptParser<T extends ParsedPubScriptTaprootScriptPath | ParsedPubScript2Of3> = (\n  p: InputPubScript,\n  ScriptType2Of3\n) => T | MatchError;\n\nfunction isLegacy(p: InputScriptsUnknown): p is InputScriptsLegacy {\n  return Boolean(p.script && !p.witness);\n}\n\nfunction isWrappedSegwit(p: InputScriptsUnknown): p is InputScriptsWrappedSegwit {\n  return Boolean(p.script && p.witness);\n}\n\nfunction isNativeSegwit(p: InputScriptsUnknown): p is InputScriptsNativeSegwit {\n  return Boolean(!p.script && p.witness);\n}\n\nconst parseP2shP2pk: InputParser<ParsedSignatureScriptP2shP2pk> = (p) => {\n  if (!isLegacy(p)) {\n    return new MatchError(`expected legacy input`);\n  }\n  const match = matchScript(p.script, [':signature', { ':script': [':pubkey', 'OP_CHECKSIG'] }]);\n  if (match instanceof MatchError) {\n    return match;\n  }\n  return {\n    scriptType: 'p2shP2pk',\n    publicKeys: match[':script'][0].match[':pubkey'] as [Buffer],\n    signatures: match[':signature'] as [Buffer],\n  };\n};\n\nfunction parseP2ms(\n  decScript: DecompiledScript,\n  scriptType: 'p2sh' | 'p2shP2wsh' | 'p2wsh'\n): ParsedSignatureScript2Of3 | MatchError {\n  const pattern2Of3: ScriptPatternElement[] = ['OP_2', ':pubkey', ':pubkey', ':pubkey', 'OP_3', 'OP_CHECKMULTISIG'];\n\n  const match = matchScriptSome(decScript, [\n    /* full-signed, no placeholder signature */\n    ['OP_0', ':signature', ':signature', { ':script': pattern2Of3 }],\n    /* half-signed, placeholder signatures */\n    ['OP_0', ':signature', ':signature', ':signature', { ':script': pattern2Of3 }],\n  ]);\n  if (match instanceof MatchError) {\n    return match;\n  }\n\n  const [redeemScript] = match[':script'];\n\n  if (!isTriple(redeemScript.match[':pubkey'])) {\n    throw new Error(`invalid pubkey count`);\n  }\n\n  return {\n    scriptType,\n    publicKeys: redeemScript.match[':pubkey'],\n    pubScript: redeemScript.buffer,\n    signatures: match[':signature'] as ParsedSignatureScript2Of3['signatures'],\n    redeemScript: scriptType === 'p2sh' ? redeemScript.buffer : undefined,\n    witnessScript: scriptType === 'p2shP2wsh' || scriptType === 'p2wsh' ? redeemScript.buffer : undefined,\n  };\n}\n\nconst parseP2sh2Of3: InputParser<ParsedSignatureScript2Of3> = (p) => {\n  if (!isLegacy(p)) {\n    return new MatchError(`expected legacy input`);\n  }\n  return parseP2ms(p.script, 'p2sh');\n};\n\nconst parseP2shP2wsh2Of3: InputParser<ParsedSignatureScript2Of3> = (p) => {\n  if (!isWrappedSegwit(p)) {\n    return new MatchError(`expected wrapped segwit input`);\n  }\n  return { ...parseP2ms(p.witness, 'p2shP2wsh'), redeemScript: p.script[0] as Buffer };\n};\n\nconst parseP2wsh2Of3: InputParser<ParsedSignatureScript2Of3> = (p) => {\n  if (!isNativeSegwit(p)) {\n    return new MatchError(`expected native segwit`);\n  }\n  return parseP2ms(p.witness, 'p2wsh');\n};\n\nconst parseP2tr2Of3: InputParser<ParsedSignatureScriptTaproot> = (p) => {\n  if (!isNativeSegwit(p)) {\n    return new MatchError(`expected native segwit`);\n  }\n  // assumes no annex\n  const match = matchScript(p.witness, [\n    ':signature',\n    ':signature',\n    { ':script': [':pubkey-xonly', 'OP_CHECKSIGVERIFY', ':pubkey-xonly', 'OP_CHECKSIG'] },\n    ':control-block',\n  ]);\n  if (match instanceof MatchError) {\n    return match;\n  }\n  const [controlBlock] = match[':control-block'];\n  const scriptPathLevel = calculateScriptPathLevel(controlBlock);\n\n  const leafVersion = getScriptPathLevel(controlBlock);\n\n  return {\n    scriptType: 'p2tr',\n    pubScript: match[':script'][0].buffer,\n    publicKeys: match[':script'][0].match[':pubkey-xonly'] as [Buffer, Buffer],\n    signatures: match[':signature'] as [Buffer, Buffer],\n    controlBlock,\n    scriptPathLevel,\n    leafVersion,\n  };\n};\n\n/**\n * Parse a transaction's signature script to obtain public keys, signatures, the sig script,\n * and other properties.\n *\n * Only supports script types used in BitGo transactions.\n *\n * @param input\n * @returns ParsedSignatureScript\n */\nexport function parseSignatureScript(\n  input: TxInput\n): ParsedSignatureScriptP2shP2pk | ParsedSignatureScript2Of3 | ParsedSignatureScriptTaproot {\n  const decScript = bscript.decompile(input.script);\n  const parsers = [parseP2sh2Of3, parseP2shP2wsh2Of3, parseP2wsh2Of3, parseP2tr2Of3, parseP2shP2pk] as const;\n  for (const f of parsers) {\n    const parsed = f({\n      script: decScript?.length === 0 ? null : decScript,\n      witness: input.witness.length === 0 ? null : input.witness,\n    });\n    if (parsed instanceof MatchError) {\n      continue;\n    }\n    return parsed;\n  }\n  throw new Error(`could not parse input`);\n}\n\nexport function parseSignatureScript2Of3(input: TxInput): ParsedSignatureScript2Of3 | ParsedSignatureScriptTaproot {\n  const result = parseSignatureScript(input);\n\n  if (!isScriptType2Of3(result.scriptType)) {\n    throw new Error(`invalid script type`);\n  }\n\n  if (!result.signatures) {\n    throw new Error(`missing signatures`);\n  }\n  if (result.publicKeys.length !== 3 && (result.publicKeys.length !== 2 || result.scriptType !== 'p2tr')) {\n    throw new Error(`unexpected pubkey count`);\n  }\n\n  return result as ParsedSignatureScript2Of3 | ParsedSignatureScriptTaproot;\n}\n\nconst parseP2msPubScript: PubScriptParser<ParsedPubScript2Of3> = (\n  pubScript,\n  scriptType: 'p2sh' | 'p2shP2wsh' | 'p2wsh'\n) => {\n  const match = matchScript(\n    [pubScript],\n    [{ ':script': ['OP_2', ':pubkey', ':pubkey', ':pubkey', 'OP_3', 'OP_CHECKMULTISIG'] }]\n  );\n  if (match instanceof MatchError) {\n    return match;\n  }\n\n  const [redeemScript] = match[':script'];\n\n  if (!isTriple(redeemScript.match[':pubkey'])) {\n    throw new Error('invalid pubkey count');\n  }\n\n  return {\n    scriptType,\n    publicKeys: redeemScript.match[':pubkey'],\n    pubScript: redeemScript.buffer,\n    redeemScript: scriptType === 'p2sh' ? redeemScript.buffer : undefined,\n    witnessScript: scriptType === 'p2shP2wsh' || scriptType === 'p2wsh' ? redeemScript.buffer : undefined,\n  };\n};\n\nconst parseP2tr2Of3PubScript: PubScriptParser<ParsedPubScriptTaprootScriptPath> = (pubScript, scriptType: 'p2tr') => {\n  const match = matchScript(\n    [pubScript],\n    [{ ':script': [':pubkey-xonly', 'OP_CHECKSIGVERIFY', ':pubkey-xonly', 'OP_CHECKSIG'] }]\n  );\n  if (match instanceof MatchError) {\n    return match;\n  }\n\n  return {\n    scriptType: 'p2tr',\n    pubScript: match[':script'][0].buffer,\n    publicKeys: match[':script'][0].match[':pubkey-xonly'] as [Buffer, Buffer],\n  };\n};\n\n/**\n * @return pubScript (scriptPubKey/redeemScript/witnessScript) is parsed.\n * P2SH => scriptType, pubScript (redeemScript), redeemScript, public keys\n * PW2SH => scriptType, pubScript (witnessScript), witnessScript, public keys.\n * P2SH-PW2SH => scriptType, pubScript (witnessScript), witnessScript, public keys.\n * P2TR => scriptType, pubScript, controlBlock, scriptPathLevel, leafVersion, pub keys, signatures.\n */\nexport function parsePubScript(\n  inputPubScript: InputPubScript,\n  scriptType: ScriptType2Of3\n): ParsedPubScript2Of3 | ParsedPubScriptTaprootScriptPath {\n  const result =\n    scriptType === 'p2tr'\n      ? parseP2tr2Of3PubScript(inputPubScript, scriptType)\n      : parseP2msPubScript(inputPubScript, scriptType);\n\n  if (result instanceof MatchError) {\n    throw new Error(result.message);\n  }\n\n  if (result.publicKeys.length !== 3 && (result.publicKeys.length !== 2 || result.scriptType !== 'p2tr')) {\n    throw new Error('unexpected pubkey count');\n  }\n\n  return result;\n}\n"]}

package/dist/src/bitgo/psbt/fromHalfSigned.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { PsbtInputUpdate } from 'bip174/src/lib/interfaces';
+import { TxOutput } from '../..';
+import { UtxoTransaction } from '../UtxoTransaction';
+export declare function getInputUpdate(tx: UtxoTransaction<bigint>, vin: number, prevOuts: (TxOutput<bigint> & {
+    prevTx?: Buffer;
+})[]): PsbtInputUpdate;
+/**
+ * Takes a partially signed transaction and removes the scripts and signatures.
+ *
+ * Inputs must be one of:
+ *  - p2shP2pk
+ *  - p2sh 2-of-3
+ *  - p2shP2wsh 2-of-3
+ *  - p2wsh 2-of-3
+ *  - p2tr script path 2-of-2
+ *
+ * @param tx the partially signed transaction
+ * @param prevOuts
+ *
+ * @return the removed scripts and signatures, ready to be added to a PSBT
+ */
+export declare function unsign(tx: UtxoTransaction<bigint>, prevOuts: TxOutput<bigint>[]): PsbtInputUpdate[];
+//# sourceMappingURL=fromHalfSigned.d.ts.map

package/dist/src/bitgo/psbt/fromHalfSigned.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromHalfSigned.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/psbt/fromHalfSigned.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,eAAe,EAAc,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAiB,QAAQ,EAAiC,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AASrD,wBAAgB,cAAc,CAC5B,EAAE,EAAE,eAAe,CAAC,MAAM,CAAC,EAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,GACnD,eAAe,CA2DjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,eAAe,EAAE,CAOnG"}

package/dist/src/bitgo/psbt/fromHalfSigned.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsign = exports.getInputUpdate = void 0;
+const __1 = require("../..");
+const parseInput_1 = require("../parseInput");
+const signature_1 = require("../signature");
+const outputScripts_1 = require("../outputScripts");
+function omitUndefined(v) {
+    return Object.fromEntries(Object.entries(v).filter(([k, v]) => v !== undefined));
+}
+function getInputUpdate(tx, vin, prevOuts) {
+    const nonWitnessUtxo = prevOuts[vin].prevTx;
+    const { script, witness } = tx.ins[vin];
+    if (script.length === 0 && witness.length === 0) {
+        return nonWitnessUtxo ? { nonWitnessUtxo } : {};
+    }
+    const parsedInput = parseInput_1.parseSignatureScript(tx.ins[vin]);
+    function getPartialSigs() {
+        return signature_1.getSignaturesWithPublicKeys(tx, vin, prevOuts, parsedInput.publicKeys).flatMap((signature, i) => signature
+            ? [
+                {
+                    pubkey: parsedInput.publicKeys[i],
+                    signature,
+                },
+            ]
+            : []);
+    }
+    // Because Zcash directly hashes the value for non-segwit transactions, we do not need to check indirectly
+    // with the previous transaction. Therefore, we can treat Zcash non-segwit transactions as Bitcoin
+    // segwit transactions
+    if (!outputScripts_1.hasWitnessData(parsedInput.scriptType) && !nonWitnessUtxo && __1.getMainnet(tx.network) !== __1.networks.zcash) {
+        throw new Error(`scriptType ${parsedInput.scriptType} requires prevTx Buffer`);
+    }
+    switch (parsedInput.scriptType) {
+        case 'p2shP2pk':
+            return {
+                nonWitnessUtxo,
+                partialSig: [{ pubkey: parsedInput.publicKeys[0], signature: parsedInput.signatures[0] }],
+            };
+        case 'p2sh':
+        case 'p2wsh':
+        case 'p2shP2wsh':
+            return omitUndefined({
+                nonWitnessUtxo,
+                partialSig: getPartialSigs(),
+                redeemScript: parsedInput.redeemScript,
+                witnessScript: parsedInput.witnessScript,
+            });
+        case 'p2tr':
+            if (!('controlBlock' in parsedInput)) {
+                throw new Error(`keypath not implemented`);
+            }
+            const leafHash = __1.taproot.getTapleafHash(__1.ecc, parsedInput.controlBlock, parsedInput.pubScript);
+            return {
+                tapLeafScript: [
+                    {
+                        controlBlock: parsedInput.controlBlock,
+                        script: parsedInput.pubScript,
+                        leafVersion: parsedInput.leafVersion,
+                    },
+                ],
+                tapScriptSig: getPartialSigs().map((obj) => ({ ...obj, leafHash })),
+            };
+    }
+}
+exports.getInputUpdate = getInputUpdate;
+/**
+ * Takes a partially signed transaction and removes the scripts and signatures.
+ *
+ * Inputs must be one of:
+ *  - p2shP2pk
+ *  - p2sh 2-of-3
+ *  - p2shP2wsh 2-of-3
+ *  - p2wsh 2-of-3
+ *  - p2tr script path 2-of-2
+ *
+ * @param tx the partially signed transaction
+ * @param prevOuts
+ *
+ * @return the removed scripts and signatures, ready to be added to a PSBT
+ */
+function unsign(tx, prevOuts) {
+    return tx.ins.map((input, vin) => {
+        const update = getInputUpdate(tx, vin, prevOuts);
+        input.witness = [];
+        input.script = Buffer.alloc(0);
+        return update;
+    });
+}
+exports.unsign = unsign;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fromHalfSigned.js","sourceRoot":"","sources":["../../../../src/bitgo/psbt/fromHalfSigned.ts"],"names":[],"mappings":";;;AACA,6BAA+E;AAE/E,8CAAqD;AACrD,4CAA2D;AAC3D,oDAAkD;AAElD,SAAS,aAAa,CAAoC,CAA0B;IAClF,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAM,CAAC;AACxF,CAAC;AAED,SAAgB,cAAc,CAC5B,EAA2B,EAC3B,GAAW,EACX,QAAoD;IAEpD,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QAC/C,OAAO,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACjD;IAED,MAAM,WAAW,GAAG,iCAAoB,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAEtD,SAAS,cAAc;QACrB,OAAO,uCAA2B,CAAC,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CACrG,SAAS;YACP,CAAC,CAAC;gBACE;oBACE,MAAM,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;oBACjC,SAAS;iBACV;aACF;YACH,CAAC,CAAC,EAAE,CACP,CAAC;IACJ,CAAC;IACD,0GAA0G;IAC1G,kGAAkG;IAClG,sBAAsB;IACtB,IAAI,CAAC,8BAAc,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,cAAc,IAAI,cAAU,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,YAAQ,CAAC,KAAK,EAAE;QAC3G,MAAM,IAAI,KAAK,CAAC,cAAc,WAAW,CAAC,UAAU,yBAAyB,CAAC,CAAC;KAChF;IAED,QAAQ,WAAW,CAAC,UAAU,EAAE;QAC9B,KAAK,UAAU;YACb,OAAO;gBACL,cAAc;gBACd,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1F,CAAC;QACJ,KAAK,MAAM,CAAC;QACZ,KAAK,OAAO,CAAC;QACb,KAAK,WAAW;YACd,OAAO,aAAa,CAAC;gBACnB,cAAc;gBACd,UAAU,EAAE,cAAc,EAAE;gBAC5B,YAAY,EAAE,WAAW,CAAC,YAAY;gBACtC,aAAa,EAAE,WAAW,CAAC,aAAa;aACzC,CAAC,CAAC;QACL,KAAK,MAAM;YACT,IAAI,CAAC,CAAC,cAAc,IAAI,WAAW,CAAC,EAAE;gBACpC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;aAC5C;YACD,MAAM,QAAQ,GAAG,WAAO,CAAC,cAAc,CAAC,OAAM,EAAE,WAAW,CAAC,YAAY,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;YACjG,OAAO;gBACL,aAAa,EAAE;oBACb;wBACE,YAAY,EAAE,WAAW,CAAC,YAAY;wBACtC,MAAM,EAAE,WAAW,CAAC,SAAS;wBAC7B,WAAW,EAAE,WAAW,CAAC,WAAW;qBACrC;iBACF;gBACD,YAAY,EAAE,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;aACpE,CAAC;KACL;AACH,CAAC;AA/DD,wCA+DC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,MAAM,CAAC,EAA2B,EAAE,QAA4B;IAC9E,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QAC/B,MAAM,MAAM,GAAG,cAAc,CAAC,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;QACjD,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC;AAPD,wBAOC","sourcesContent":["import { PsbtInputUpdate, PartialSig } from 'bip174/src/lib/interfaces';\nimport { ecc as eccLib, TxOutput, taproot, getMainnet, networks } from '../..';\nimport { UtxoTransaction } from '../UtxoTransaction';\nimport { parseSignatureScript } from '../parseInput';\nimport { getSignaturesWithPublicKeys } from '../signature';\nimport { hasWitnessData } from '../outputScripts';\n\nfunction omitUndefined<T extends Record<string, unknown>>(v: Record<string, unknown>): T {\n  return Object.fromEntries(Object.entries(v).filter(([k, v]) => v !== undefined)) as T;\n}\n\nexport function getInputUpdate(\n  tx: UtxoTransaction<bigint>,\n  vin: number,\n  prevOuts: (TxOutput<bigint> & { prevTx?: Buffer })[]\n): PsbtInputUpdate {\n  const nonWitnessUtxo = prevOuts[vin].prevTx;\n  const { script, witness } = tx.ins[vin];\n  if (script.length === 0 && witness.length === 0) {\n    return nonWitnessUtxo ? { nonWitnessUtxo } : {};\n  }\n\n  const parsedInput = parseSignatureScript(tx.ins[vin]);\n\n  function getPartialSigs(): PartialSig[] {\n    return getSignaturesWithPublicKeys(tx, vin, prevOuts, parsedInput.publicKeys).flatMap((signature, i) =>\n      signature\n        ? [\n            {\n              pubkey: parsedInput.publicKeys[i],\n              signature,\n            },\n          ]\n        : []\n    );\n  }\n  // Because Zcash directly hashes the value for non-segwit transactions, we do not need to check indirectly\n  // with the previous transaction. Therefore, we can treat Zcash non-segwit transactions as Bitcoin\n  // segwit transactions\n  if (!hasWitnessData(parsedInput.scriptType) && !nonWitnessUtxo && getMainnet(tx.network) !== networks.zcash) {\n    throw new Error(`scriptType ${parsedInput.scriptType} requires prevTx Buffer`);\n  }\n\n  switch (parsedInput.scriptType) {\n    case 'p2shP2pk':\n      return {\n        nonWitnessUtxo,\n        partialSig: [{ pubkey: parsedInput.publicKeys[0], signature: parsedInput.signatures[0] }],\n      };\n    case 'p2sh':\n    case 'p2wsh':\n    case 'p2shP2wsh':\n      return omitUndefined({\n        nonWitnessUtxo,\n        partialSig: getPartialSigs(),\n        redeemScript: parsedInput.redeemScript,\n        witnessScript: parsedInput.witnessScript,\n      });\n    case 'p2tr':\n      if (!('controlBlock' in parsedInput)) {\n        throw new Error(`keypath not implemented`);\n      }\n      const leafHash = taproot.getTapleafHash(eccLib, parsedInput.controlBlock, parsedInput.pubScript);\n      return {\n        tapLeafScript: [\n          {\n            controlBlock: parsedInput.controlBlock,\n            script: parsedInput.pubScript,\n            leafVersion: parsedInput.leafVersion,\n          },\n        ],\n        tapScriptSig: getPartialSigs().map((obj) => ({ ...obj, leafHash })),\n      };\n  }\n}\n\n/**\n * Takes a partially signed transaction and removes the scripts and signatures.\n *\n * Inputs must be one of:\n *  - p2shP2pk\n *  - p2sh 2-of-3\n *  - p2shP2wsh 2-of-3\n *  - p2wsh 2-of-3\n *  - p2tr script path 2-of-2\n *\n * @param tx the partially signed transaction\n * @param prevOuts\n *\n * @return the removed scripts and signatures, ready to be added to a PSBT\n */\nexport function unsign(tx: UtxoTransaction<bigint>, prevOuts: TxOutput<bigint>[]): PsbtInputUpdate[] {\n  return tx.ins.map((input, vin) => {\n    const update = getInputUpdate(tx, vin, prevOuts);\n    input.witness = [];\n    input.script = Buffer.alloc(0);\n    return update;\n  });\n}\n"]}

package/dist/src/bitgo/psbt/scriptTypes.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare function isP2wsh(scriptPubkey: Buffer, redeemScript?: Buffer): boolean;
+export declare function isP2wpkh(scriptPubkey: Buffer, redeemScript?: Buffer): boolean;
+export declare function isTaproot(scriptPubkey: Buffer): boolean;
+export declare function isSegwit(scriptPubkey: Buffer, redeemScript?: Buffer): boolean;
+//# sourceMappingURL=scriptTypes.d.ts.map

package/dist/src/bitgo/psbt/scriptTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scriptTypes.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/psbt/scriptTypes.ts"],"names":[],"mappings":";AAEA,wBAAgB,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAG5E;AAED,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAG7E;AAED,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAE7E"}

package/dist/src/bitgo/psbt/scriptTypes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSegwit = exports.isTaproot = exports.isP2wpkh = exports.isP2wsh = void 0;
+const opcodes = require("bitcoin-ops");
+function isP2wsh(scriptPubkey, redeemScript) {
+    const witnessProgramCandidate = redeemScript !== null && redeemScript !== void 0 ? redeemScript : scriptPubkey;
+    return witnessProgramCandidate[0] === opcodes.OP_0 && witnessProgramCandidate.length === 34;
+}
+exports.isP2wsh = isP2wsh;
+function isP2wpkh(scriptPubkey, redeemScript) {
+    const witnessProgramCandidate = redeemScript !== null && redeemScript !== void 0 ? redeemScript : scriptPubkey;
+    return witnessProgramCandidate[0] === opcodes.OP_0 && witnessProgramCandidate.length === 22;
+}
+exports.isP2wpkh = isP2wpkh;
+function isTaproot(scriptPubkey) {
+    return scriptPubkey[0] === opcodes.OP_1 && scriptPubkey.length === 34;
+}
+exports.isTaproot = isTaproot;
+function isSegwit(scriptPubkey, redeemScript) {
+    return isTaproot(scriptPubkey) || isP2wsh(scriptPubkey, redeemScript) || isP2wpkh(scriptPubkey, redeemScript);
+}
+exports.isSegwit = isSegwit;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyaXB0VHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYml0Z28vcHNidC9zY3JpcHRUeXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBdUM7QUFFdkMsU0FBZ0IsT0FBTyxDQUFDLFlBQW9CLEVBQUUsWUFBcUI7SUFDakUsTUFBTSx1QkFBdUIsR0FBRyxZQUFZLGFBQVosWUFBWSxjQUFaLFlBQVksR0FBSSxZQUFZLENBQUM7SUFDN0QsT0FBTyx1QkFBdUIsQ0FBQyxDQUFDLENBQUMsS0FBSyxPQUFPLENBQUMsSUFBSSxJQUFJLHVCQUF1QixDQUFDLE1BQU0sS0FBSyxFQUFFLENBQUM7QUFDOUYsQ0FBQztBQUhELDBCQUdDO0FBRUQsU0FBZ0IsUUFBUSxDQUFDLFlBQW9CLEVBQUUsWUFBcUI7SUFDbEUsTUFBTSx1QkFBdUIsR0FBRyxZQUFZLGFBQVosWUFBWSxjQUFaLFlBQVksR0FBSSxZQUFZLENBQUM7SUFDN0QsT0FBTyx1QkFBdUIsQ0FBQyxDQUFDLENBQUMsS0FBSyxPQUFPLENBQUMsSUFBSSxJQUFJLHVCQUF1QixDQUFDLE1BQU0sS0FBSyxFQUFFLENBQUM7QUFDOUYsQ0FBQztBQUhELDRCQUdDO0FBRUQsU0FBZ0IsU0FBUyxDQUFDLFlBQW9CO0lBQzVDLE9BQU8sWUFBWSxDQUFDLENBQUMsQ0FBQyxLQUFLLE9BQU8sQ0FBQyxJQUFJLElBQUksWUFBWSxDQUFDLE1BQU0sS0FBSyxFQUFFLENBQUM7QUFDeEUsQ0FBQztBQUZELDhCQUVDO0FBRUQsU0FBZ0IsUUFBUSxDQUFDLFlBQW9CLEVBQUUsWUFBcUI7SUFDbEUsT0FBTyxTQUFTLENBQUMsWUFBWSxDQUFDLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsSUFBSSxRQUFRLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQyxDQUFDO0FBQ2hILENBQUM7QUFGRCw0QkFFQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIG9wY29kZXMgZnJvbSAnYml0Y29pbi1vcHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gaXNQMndzaChzY3JpcHRQdWJrZXk6IEJ1ZmZlciwgcmVkZWVtU2NyaXB0PzogQnVmZmVyKTogYm9vbGVhbiB7XG4gIGNvbnN0IHdpdG5lc3NQcm9ncmFtQ2FuZGlkYXRlID0gcmVkZWVtU2NyaXB0ID8/IHNjcmlwdFB1YmtleTtcbiAgcmV0dXJuIHdpdG5lc3NQcm9ncmFtQ2FuZGlkYXRlWzBdID09PSBvcGNvZGVzLk9QXzAgJiYgd2l0bmVzc1Byb2dyYW1DYW5kaWRhdGUubGVuZ3RoID09PSAzNDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzUDJ3cGtoKHNjcmlwdFB1YmtleTogQnVmZmVyLCByZWRlZW1TY3JpcHQ/OiBCdWZmZXIpOiBib29sZWFuIHtcbiAgY29uc3Qgd2l0bmVzc1Byb2dyYW1DYW5kaWRhdGUgPSByZWRlZW1TY3JpcHQgPz8gc2NyaXB0UHVia2V5O1xuICByZXR1cm4gd2l0bmVzc1Byb2dyYW1DYW5kaWRhdGVbMF0gPT09IG9wY29kZXMuT1BfMCAmJiB3aXRuZXNzUHJvZ3JhbUNhbmRpZGF0ZS5sZW5ndGggPT09IDIyO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNUYXByb290KHNjcmlwdFB1YmtleTogQnVmZmVyKTogYm9vbGVhbiB7XG4gIHJldHVybiBzY3JpcHRQdWJrZXlbMF0gPT09IG9wY29kZXMuT1BfMSAmJiBzY3JpcHRQdWJrZXkubGVuZ3RoID09PSAzNDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzU2Vnd2l0KHNjcmlwdFB1YmtleTogQnVmZmVyLCByZWRlZW1TY3JpcHQ/OiBCdWZmZXIpOiBib29sZWFuIHtcbiAgcmV0dXJuIGlzVGFwcm9vdChzY3JpcHRQdWJrZXkpIHx8IGlzUDJ3c2goc2NyaXB0UHVia2V5LCByZWRlZW1TY3JpcHQpIHx8IGlzUDJ3cGtoKHNjcmlwdFB1YmtleSwgcmVkZWVtU2NyaXB0KTtcbn1cbiJdfQ==