@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

package/.yalc/@node-dlc/bitcoin/lib/Script.ts

@@ -0,0 +1,509 @@
+import { bigToBufLE } from '@node-dlc/bufio';
+import { encodeVarInt } from '@node-dlc/bufio';
+import { BufferReader } from '@node-dlc/bufio';
+import { StreamReader } from '@node-dlc/bufio';
+import { hash160, isDERSig, sha256, validPublicKey } from '@node-dlc/crypto';
+
+import { BitcoinError } from './BitcoinError';
+import { BitcoinErrorCode } from './BitcoinErrorCode';
+import { ICloneable } from './ICloneable';
+import { OpCode } from './OpCodes';
+import { ScriptCmd } from './ScriptCmd';
+import { isSigHashTypeValid } from './SigHashType';
+import { Stack } from './Stack';
+
+function asssertValidSig(sig: Buffer) {
+  const der = sig.slice(0, sig.length - 1);
+  const hashtype = sig[sig.length - 1];
+
+  if (!isDERSig(der)) {
+    throw new BitcoinError(BitcoinErrorCode.SigEncodingInvalid);
+  }
+
+  if (!isSigHashTypeValid(hashtype)) {
+    throw new BitcoinError(BitcoinErrorCode.SigHashTypeInvalid, hashtype);
+  }
+}
+
+function assertValidPubKey(pubkey: Buffer) {
+  if (!validPublicKey(pubkey)) {
+    throw new BitcoinError(BitcoinErrorCode.PubKeyInvalid);
+  }
+}
+
+/**
+ * Bitcoin Script
+ */
+export class Script implements ICloneable<Script> {
+  /**
+   *
+   * @param val
+   */
+  public static number(val: number | bigint): ScriptCmd {
+    // Zero is encoded as OP_0
+    if (val === 0 || val === BigInt(0)) {
+      return OpCode.OP_0;
+    }
+
+    // 1-16 is encoded as OP_1 to OP_16
+    if (val >= 1 && val <= 16) {
+      return 0x50 + Number(val);
+    }
+
+    // anything else is encoded as signed-magnitude value
+    // and added to the script as raw push bytes
+    return Stack.encodeNum(val);
+  }
+
+  /**
+   * Creates a standard (though no longer used) pay-to-pubkey
+   * scriptPubKey using the provided pubkey.
+   *
+   * P2PK format:
+   *      <pubkey> OP_CHECKSIG
+   *
+   * @param pubkey 33-byte compressed or 65-byte uncompressed SEC
+   * encoded pubkey
+   */
+  public static p2pkLock(pubkey: Buffer): Script {
+    assertValidPubKey(pubkey);
+    return new Script(pubkey, OpCode.OP_CHECKSIG);
+  }
+
+  /**
+   * Creates a standard (though no longer used) pay-to-pubkey
+   * scriptSig using the provided signature.
+   *
+   * P2PK format:
+   *      <sig>
+   *
+   * @param sig DER encoded signature + 1-byte sighash type
+   */
+  public static p2pkUnlock(sig: Buffer): Script {
+    asssertValidSig(sig);
+    return new Script(sig);
+  }
+
+  /**
+   * Creates a standard Pay-to-Public-Key-Hash scriptPubKey by accepting a
+   * hash of a public key as input and generating the script in the standard
+   * P2PKH script format:
+   *   OP_DUP OP_HASH160 <hash160pubkey> OP_EQUALVERIFY OP_CHECKSIG
+   *
+   * @param value either the 20-byte hash160 of a pubkey or an SEC
+   * encoded compressed or uncompressed pubkey
+   */
+  public static p2pkhLock(value: Buffer): Script {
+    // if not a hash160, then it must be a valid pubkey
+    if (value.length !== 20) {
+      assertValidPubKey(value);
+    }
+
+    // either the hash value or a valid pubkey that needs to be hashed
+    const hash160PubKey = value.length === 20 ? value : hash160(value);
+
+    return new Script(
+      OpCode.OP_DUP,
+      OpCode.OP_HASH160,
+      hash160PubKey,
+      OpCode.OP_EQUALVERIFY,
+      OpCode.OP_CHECKSIG,
+    );
+  }
+
+  /**
+   * Creates a standard Pay-to-Public-Key-Hash scriptSig
+   * @param sig BIP66 compliant DER encoded signuture + hash byte
+   * @param pubkey SEC encoded public key
+   */
+  public static p2pkhUnlock(sig: Buffer, pubkey: Buffer): Script {
+    asssertValidSig(sig);
+    assertValidPubKey(pubkey);
+    return new Script(sig, pubkey);
+  }
+
+  /**
+   * Creates a standard Pay-to-MultiSig scriptPubKey by accepting m of n
+   * public keys as inputs in the format:
+   *   OP_<m> <pubkey1> <pubkey2> <pubkey..m> OP_<n> OP_CHECKMULTISIG
+   */
+  public static p2msLock(m: number, ...pubkeys: Buffer[]): Script {
+    // assert all public keys are valid
+    for (const pubkey of pubkeys) {
+      assertValidPubKey(pubkey);
+    }
+
+    // ensure proper number of keys
+    if (
+      m < 1 ||
+      m > pubkeys.length ||
+      pubkeys.length === 0 ||
+      pubkeys.length > 20
+    ) {
+      throw new BitcoinError(BitcoinErrorCode.MultiSigSetupInvalid);
+    }
+
+    return new Script(
+            Script.number(m),
+            ...pubkeys,
+            Script.number(pubkeys.length),
+            OpCode.OP_CHECKMULTISIG,
+        ); // prettier-ignore
+  }
+
+  /**
+   * Creates a standard Pay-to-MultiSig scripSig using the provided
+   * signatures. The signatures must be in the order of the pub keys
+   * used in the lock script. This function also correctly adds OP_0
+   * as the first element on the stack to ensure the p2ms off-by-one
+   * error is correctly accounted for.
+   *
+   * Each signature must be DER encoded using BIP66 and
+   * include a 1-byte sighash type at the end. The builder validates
+   * the signatures. As such they will be 10 to 74 bytes.
+   *
+   * @param pubkeys
+   */
+  public static p2msUnlock(...sigs: Buffer[]): Script {
+    // assert all signatures
+    for (const sig of sigs) {
+      asssertValidSig(sig);
+    }
+    return new Script(
+            OpCode.OP_0,
+            ...sigs
+        ); // prettier-ignore
+  }
+
+  /**
+   * Creates a standard Pay-to-Script-Hash scriptPubKey by accepting a hash of
+   * the redeem script as input and generating the P2SH script:
+   *   OP_HASH160 <hashScript> OP_EQUAL
+   *
+   * Accepts the redeem script either as a Script object or as the
+   * hash160 of the redeem script. When the hash160 Buffer is provided
+   * it will throw if the Buffer is not 20-bytes.
+   *
+   * @param value can be either the redeem script as a Script type or
+   * the hash160 as a 20-byte buffer
+   */
+  public static p2shLock(value: Script | Buffer): Script {
+    const scriptHash160 = value instanceof Script ? value.hash160() : value;
+
+    if (scriptHash160.length !== 20) {
+      throw new BitcoinError(BitcoinErrorCode.Hash160Invalid, {
+        got: scriptHash160.length,
+        expected: 20,
+      });
+    }
+
+    return new Script(
+            OpCode.OP_HASH160,
+            scriptHash160,
+            OpCode.OP_EQUAL,
+        ); // prettier-ignore
+  }
+
+  /**
+   * Creates a p2sh unlock script for use in a transaction input
+   * scriptSig value. The redeem script, which is the preimage of the
+   * of the script hash used to lock the p2sh output, must be provided
+   * along with any additional data required to unlock the script.
+   *
+   * @param redeemScript preimage of the script hash
+   * @param data script commands will be added as unlock data
+   */
+  public static p2shUnlock(redeemScript: Script, data: Script): Script;
+
+  /**
+   * Creates a p2sh unlock script for use in a transaction input
+   * scriptSig value. The redeem script, which is the preimage of the
+   * of the script hash used to lock the p2sh output, must be provided
+   * along with any additional data required to unlock the script.
+   *
+   * @param redeemScript preimage of the script hash
+   * @param data ScriptCmd data used to unlock the script
+   */
+  public static p2shUnlock(redeemScript: Script, ...data: ScriptCmd[]): Script;
+
+  public static p2shUnlock(
+    redeemScript: Script,
+    ...data: Script[] | ScriptCmd[]
+  ): Script {
+    if (data[0] instanceof Script) {
+      return new Script(...data[0].cmds, redeemScript.serializeCmds());
+    } else {
+      return new Script(...(data as ScriptCmd[]), redeemScript.serializeCmds());
+    }
+  }
+
+  /**
+   * Create a standard Pay-to-Witness-PubKey-Hash scriptPubKey by accepting
+   * the hash160 of a compressed public key point as input. It is of the
+   * format:
+   *   OP_0 <hash160_pubkey>
+   *
+   * @param value either a 20-byte pubkeyhash or a valid pubkey
+   */
+  public static p2wpkhLock(value: Buffer): Script {
+    // if not a hash160, then it must be a valid pubkey
+    if (value.length !== 20) {
+      assertValidPubKey(value);
+    }
+
+    // either the hash value or a valid pubkey that needs to be hashed
+    const hash160PubKey = value.length === 20 ? value : hash160(value);
+
+    return new Script(
+            OpCode.OP_0,
+            hash160PubKey,
+        ); // prettier-ignore
+  }
+
+  /**
+   * Create a standard Pay-to-Witness-Script-Hash scriptPubKey by accepting
+   * the sha256 of the witness script as input. It is of the format:
+   *   OP_0 <sha256_redeem_script>
+   */
+  public static p2wshLock(value: Buffer | Script): Script {
+    const sha256Script =
+      value instanceof Buffer ? value : sha256(value.serializeCmds());
+
+    if (sha256Script.length !== 32) {
+      throw new BitcoinError(BitcoinErrorCode.Hash256Invalid);
+    }
+
+    return new Script(
+            OpCode.OP_0,
+            sha256Script,
+        ); // prettier-ignore
+  }
+
+  /**
+   * Parses a stream of bytes representing a Script. The stream must start
+   * with a Varint length of Script data. The Script data is then parsed into
+   * data blocks or op_codes depending on the meaning of the bytes
+   * @param stream
+   */
+  public static parse(reader: StreamReader): Script {
+    // read the length
+    const len = reader.readVarInt();
+
+    // read the length of bytes occupied by the script and then pass it
+    // through the command parser.
+    const buf = reader.readBytes(Number(len));
+    const cmds = Script.parseCmds(buf);
+
+    // return the script object with the commands
+    return new Script(...cmds);
+  }
+
+  /**
+   * When supplied with a Buffer of cmds this method will parse the commands
+   * into data blocks or op_codes depending on the meaning of the bytes
+   * @param buf
+   */
+  public static parseCmds(buf: Buffer): ScriptCmd[] {
+    const br = new BufferReader(buf);
+
+    // commands that were read off the stack
+    const cmds: ScriptCmd[] = [];
+
+    // loop until all bytes have been read
+    while (!br.eof) {
+      // read the current command from the stream
+      const op = br.readUInt8();
+
+      // data range between 1-75 bytes is OP_PUSHBYTES_xx and we simple
+      // read the xx number of bytes off the script
+      if (op >= 0x01 && op <= 0x4b) {
+        const n = op;
+        const bytes = br.readBytes(n);
+        cmds.push(bytes);
+      }
+
+      // data range between 76 and 255 bytes uses OP_PUSHDATA1 and uses
+      // the format with a single byte length and then the n bytes are
+      // read from the script
+      else if (op === OpCode.OP_PUSHDATA1) {
+        const n = br.readUInt8();
+        cmds.push(br.readBytes(n));
+      }
+
+      // data range between 256 and 520 uses OP_PUSHDATA2 and uses the
+      // format with two bytes little-endian to determine the n bytes of
+      // data of data that need to be read.
+      else if (op === OpCode.OP_PUSHDATA2) {
+        const n = br.readUInt16LE();
+        cmds.push(br.readBytes(n));
+      }
+
+      // otherwise the value is an opcode that should be added to the cmds
+      else {
+        cmds.push(op);
+      }
+    }
+
+    return cmds;
+  }
+
+  /**
+   * Commands belonging to the script
+   */
+  public readonly cmds: ScriptCmd[];
+
+  /**
+   * Constructs a Script with the supplied ScriptCmd values
+   * @param cmds
+   */
+  constructor(...cmds: ScriptCmd[]) {
+    this.cmds = cmds;
+  }
+
+  /**
+   * Returns true if other script is an exact match of the current script.
+   * This requires all data element sto be exact matches and all operations
+   * to be exact matches.
+   * @param other
+   */
+  public equals(other: Script): boolean {
+    if (this.cmds.length !== other.cmds.length) return false;
+    for (let i = 0; i < this.cmds.length; i++) {
+      const l = this.cmds[i];
+      const r = other.cmds[i];
+      if (Buffer.isBuffer(l) && Buffer.isBuffer(r)) {
+        if (!l.equals(r)) return false;
+      } else {
+        if (l !== r) return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Returns a string with the friendly name of the opcode. For data,
+   * it returns the value in hexadecimal format.
+   */
+  public toString(): string {
+    return this.cmds
+      .map((cmd) => {
+        if (Buffer.isBuffer(cmd)) {
+          return cmd.toString('hex');
+        } else {
+          return OpCode[cmd as OpCode];
+        }
+      })
+      .join(' ');
+  }
+
+  /**
+   * Returns a JSON serialization of the Script.
+   */
+  public toJSON(): string {
+    return this.toString();
+  }
+
+  /**
+   * Serializes the Script to a Buffer by serializing the cmds prefixed with
+   * the overall length as a varint. Therefore the format of this method is
+   * the format used when encoding a Script and is:
+   *
+   * [varint]: length
+   * [length]: script_cmds
+   */
+  public serialize(): Buffer {
+    // first obtain the length of all commands in the script
+    const cmdBuf = this.serializeCmds();
+
+    // capture the length of cmd buffer
+    const len = encodeVarInt(cmdBuf.length);
+
+    // return combined buffer
+    return Buffer.concat([len, cmdBuf]);
+  }
+
+  /**
+   * Serializes the commands to a buffer. This information is the raw
+   * serialization and can be directly parsed with the `parseCmds` method.
+   */
+  public serializeCmds(): Buffer {
+    const results: Buffer[] = [];
+    for (const op of this.cmds) {
+      // OP_CODES are just an integers and can just be pushed directly onto
+      // the byte array after being converted into a single byte buffer
+      if (typeof op === 'number') {
+        const opBuf = Buffer.from([op]);
+        results.push(opBuf);
+      }
+
+      // elements will be represented as a buffer of information and we will
+      // use the length to determine how to encode it
+      else if (op instanceof Buffer) {
+        // between 1 and 75 bytes are OP_PUSHBYTES_XX
+        // there is no op_code for these. We first need to push
+        // the length of the buffer array though as the operation
+        if (op.length >= 1 && op.length <= 75) {
+          results.push(Buffer.from([op.length]));
+          results.push(op);
+        }
+
+        // between 76 and 255 uses OP_PUSHDATA1
+        // this requires us to push the op_code, a single byte length
+        // and finally push the 76-255 bytes of data
+        else if (op.length >= 76 && op.length <= 255) {
+          results.push(Buffer.from([OpCode.OP_PUSHDATA1])); // op_pushdata1
+          results.push(Buffer.from([op.length])); // single-byte
+          results.push(op);
+        }
+
+        // between 256 and 520 uses OP_PUSHDATA2
+        // this requires us to push the op_code, a two-byte little-endian number
+        // and finally push the 256-520 bytes of data
+        else if (op.length >= 256 && op.length <= 520) {
+          results.push(Buffer.from([OpCode.OP_PUSHDATA2])); // op_pushdata2
+          results.push(bigToBufLE(BigInt(op.length), 2)); // two-bytes little-endian
+          results.push(op);
+        }
+
+        // data longer than 520 is not supported
+        else {
+          throw new Error('Data too long');
+        }
+      }
+    }
+
+    // combine all parts of data
+    return Buffer.concat(results);
+  }
+
+  /**
+   * Clone via deep copy
+   */
+  public clone(): Script {
+    return new Script(
+      ...this.cmds.map((cmd) => {
+        if (Buffer.isBuffer(cmd)) {
+          return Buffer.from(cmd);
+        } else {
+          return cmd;
+        }
+      }),
+    );
+  }
+
+  /**
+   * Performs a hash160 on the serialized commands. This is useful for
+   * turning a script into a P2SH redeem script.
+   */
+  public hash160(): Buffer {
+    return hash160(this.serializeCmds());
+  }
+
+  /**
+   * Performs a sha256 hash on the serialized commands. This is useful
+   * fro turning a script into a P2WSH lock script.
+   */
+  public sha256(): Buffer {
+    return sha256(this.serializeCmds());
+  }
+}

package/.yalc/@node-dlc/bitcoin/lib/ScriptCmd.ts

@@ -0,0 +1,3 @@
+import { OpCode } from './OpCodes';
+
+export type ScriptCmd = OpCode | Buffer;