@bsv/sdk 1.0.0 → 1.0.1

package/src/primitives/Signature.ts

@@ -1,235 +0,0 @@
-import BigNumber from './BigNumber.js'
-import PublicKey from './PublicKey.js'
-import { verify } from './ECDSA.js'
-import { sha256 } from './Hash.js'
-import { toArray, toHex, toBase64 } from './utils.js'
-
-/**
- * Represents a digital signature.
- *
- * A digital signature is a mathematical scheme for verifying the authenticity of
- * digital messages or documents. In many scenarios, it is equivalent to a handwritten signature or stamped seal.
- * The signature pair (R, S) corresponds to the raw ECDSA ([Elliptic Curve Digital Signature Algorithm](https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm)) signature.
- * Signatures are often serialized into a format known as '[DER encoding](https://en.wikipedia.org/wiki/X.690#DER_encoding)' for transmission.
- *
- * @class Signature
- */
-export default class Signature {
-  /**
-   * @property Represents the "r" component of the digital signature
-   */
-  r: BigNumber
-
-  /**
-   * @property Represents the "s" component of the digital signature
-   */
-  s: BigNumber
-
-  /**
-   * Takes an array of numbers or a string and returns a new Signature instance.
-   * This method will throw an error if the DER encoding is invalid.
-   * If a string is provided, it is assumed to represent a hexadecimal sequence.
-   *
-   * @static
-   * @method fromDER
-   * @param data - The sequence to decode from DER encoding.
-   * @param enc - The encoding of the data string.
-   * @returns The decoded data in the form of Signature instance.
-   *
-   * @example
-   * const signature = Signature.fromDER('30440220018c1f5502f8...', 'hex');
-   */
-  static fromDER(data: number[] | string, enc?: 'hex' | 'base64'): Signature {
-    const getLength = (buf, p): number => {
-      const initial = buf[p.place++]
-      if ((initial & 0x80) === 0) {
-        return initial
-      } else {
-        throw new Error('Invalid DER entity length')
-      }
-    }
-
-    class Position {
-      place: number
-      constructor() {
-        this.place = 0
-      }
-    }
-    data = toArray(data, enc)
-
-    // Support compact signatures
-    if (data.length === 65) {
-      return new Signature(
-        new BigNumber(data.slice(1, 33)),
-        new BigNumber(data.slice(33, 65))
-      )
-    }
-
-    const p = new Position()
-    if (data[p.place++] !== 0x30) {
-      throw new Error('Signature DER must start with 0x30')
-    }
-    const len = getLength(data, p)
-    if ((len + p.place) !== data.length) {
-      throw new Error('Signature DER invalid')
-    }
-    if (data[p.place++] !== 0x02) {
-      throw new Error('Signature DER invalid')
-    }
-    const rlen = getLength(data, p)
-    let r = data.slice(p.place, rlen + p.place)
-    p.place += rlen
-    if (data[p.place++] !== 0x02) {
-      throw new Error('Signature DER invalid')
-    }
-    const slen = getLength(data, p)
-    if (data.length !== slen + p.place) {
-      throw new Error('Invalid R-length in signature DER')
-    }
-    let s = data.slice(p.place, slen + p.place)
-    if (r[0] === 0) {
-      if ((r[1] & 0x80) !== 0) {
-        r = r.slice(1)
-      } else {
-        throw new Error('Invalid R-value in signature DER')
-      }
-    }
-    if (s[0] === 0) {
-      if ((s[1] & 0x80) !== 0) {
-        s = s.slice(1)
-      } else {
-        throw new Error('Invalid S-value in signature DER')
-      }
-    }
-
-    return new Signature(
-      new BigNumber(r),
-      new BigNumber(s)
-    )
-  }
-
-  /**
-   * Creates an instance of the Signature class.
-   *
-   * @constructor
-   * @param r - The R component of the signature.
-   * @param s - The S component of the signature.
-   *
-   * @example
-   * const r = new BigNumber('208755674028...');
-   * const s = new BigNumber('564745627577...');
-   * const signature = new Signature(r, s);
-   */
-  constructor(r: BigNumber, s: BigNumber) {
-    this.r = r
-    this.s = s
-  }
-
-  /**
-   * Verifies a digital signature.
-   *
-   * This method will return true if the signature, key, and message hash match.
-   * If the data or key do not match the signature, the function returns false.
-   *
-   * @method verify
-   * @param msg - The message to verify.
-   * @param key - The public key used to sign the original message.
-   * @param enc - The encoding of the msg string.
-   * @returns A boolean representing whether the signature is valid.
-   *
-   * @example
-   * const msg = 'The quick brown fox jumps over the lazy dog';
-   * const publicKey = PublicKey.fromString('04188ca1050...');
-   * const isVerified = signature.verify(msg, publicKey);
-   */
-  verify(msg: number[] | string, key: PublicKey, enc?: 'hex'): boolean {
-    const msgHash = new BigNumber(sha256(msg, enc), 16)
-    return verify(msgHash, this, key)
-  }
-
-  /**
-   * Converts an instance of Signature into DER encoding.
-   * An alias for the toDER method.
-   *
-   * If the encoding parameter is set to 'hex', the function will return a hex string.
-   * If 'base64', it will return a base64 string.
-   * Otherwise, it will return an array of numbers.
-   *
-   * @method toDER
-   * @param enc - The encoding to use for the output.
-   * @returns The current instance in DER encoding.
-   *
-   * @example
-   * const der = signature.toString('base64');
-   */
-  toString(enc?: 'hex' | 'base64') {
-    return this.toDER(enc)
-  }
-
-  /**
-   * Converts an instance of Signature into DER encoding.
-   *
-   * If the encoding parameter is set to 'hex', the function will return a hex string.
-   * If 'base64', it will return a base64 string.
-   * Otherwise, it will return an array of numbers.
-   *
-   * @method toDER
-   * @param enc - The encoding to use for the output.
-   * @returns The current instance in DER encoding.
-   *
-   * @example
-   * const der = signature.toDER('hex');
-   */
-  toDER(enc?: 'hex' | 'base64'): number[] | string {
-    const constructLength = (arr, len): void => {
-      if (len < 0x80) {
-        arr.push(len)
-      } else {
-        throw new Error('len must be < 0x80')
-      }
-    }
-
-    const rmPadding = (buf: number[]): number[] => {
-      let i = 0
-      const len = buf.length - 1
-      while ((buf[i] === 0) && ((buf[i + 1] & 0x80) === 0) && i < len) {
-        i++
-      }
-      if (i === 0) {
-        return buf
-      }
-      return buf.slice(i)
-    }
-
-    let r = this.r.toArray()
-    let s = this.s.toArray()
-
-    // Pad values
-    if ((r[0] & 0x80) !== 0) { r = [0].concat(r) }
-    // Pad values
-    if ((s[0] & 0x80) !== 0) { s = [0].concat(s) }
-
-    r = rmPadding(r)
-    s = rmPadding(s)
-
-    while ((s[0] === 0) && (s[1] & 0x80) === 0) {
-      s = s.slice(1)
-    }
-    let arr = [0x02]
-    constructLength(arr, r.length)
-    arr = arr.concat(r)
-    arr.push(0x02)
-    constructLength(arr, s.length)
-    const backHalf = arr.concat(s)
-    let res = [0x30]
-    constructLength(res, backHalf.length)
-    res = res.concat(backHalf)
-    if (enc === 'hex') {
-      return toHex(res)
-    } else if (enc === 'base64') {
-      return toBase64(res)
-    } else {
-      return res
-    }
-  }
-}

package/src/primitives/SymmetricKey.ts

@@ -1,75 +0,0 @@
-import BigNumber from './BigNumber.js'
-import { AESGCM, AESGCMDecrypt } from './AESGCM.js'
-import Random from './Random.js'
-import { toArray, encode } from './utils.js'
-
-/**
- * `SymmetricKey` is a class that extends the `BigNumber` class and implements symmetric encryption and decryption methods.
- * Symmetric-Key encryption is a form of encryption where the same key is used to encrypt and decrypt the message.
- * It leverages the Advanced Encryption Standard Galois/Counter Mode (AES-GCM) for encryption and decryption of messages.
- *
- * @class SymmetricKey
- * @extends {BigNumber}
- */
-export default class SymmetricKey extends BigNumber {
-  /**
-  * Encrypts a given message using AES-GCM encryption.
-  * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
-  * The OpenSSL format of |IV|encryptedContent|authTag| is used.
-  *
-  * @method encrypt
-  * @param msg - The message to be encrypted. It can be a string or an array of numbers.
-  * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
-  * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
-  *
-  * @example
-  * const key = new SymmetricKey(1234);
-  * const encryptedMessage = key.encrypt('plainText', 'utf8');
-  */
-  encrypt (msg: number[] | string, enc?: 'hex'): string | number[] {
-    const iv = Random(32)
-    msg = toArray(msg, enc)
-    const { result, authenticationTag } = AESGCM(
-      msg,
-      [],
-      iv,
-      this.toArray()
-    )
-    return encode([...iv, ...result, ...authenticationTag], enc)
-  }
-
-  /**
-   * Decrypts a given AES-GCM encrypted message using the same key that was used for encryption.
-   * The method extracts the IV and the authentication tag from the encrypted message, then attempts to decrypt it.
-   * If the decryption fails (e.g., due to message tampering), an error is thrown.
-   *
-   * @method decrypt
-   * @param msg - The encrypted message to be decrypted. It can be a string or an array of numbers.
-   * @param enc - optional. The encoding of the message (if no encoding is provided, uses utf8 for strings, unless specified as hex).
-   * @returns Returns the decrypted message as a string or an array of numbers, depending on `enc` argument. If absent, an array of numbers is returned.
-   *
-   * @example
-   * const key = new SymmetricKey(1234);
-   * const decryptedMessage = key.decrypt(encryptedMessage, 'utf8');
-   *
-   * @throws {Error} Will throw an error if the decryption fails, likely due to message tampering or incorrect decryption key.
-   */
-  decrypt (msg: number[] | string, enc?: 'hex' | 'utf8'): string | number[] {
-    msg = toArray(msg, enc) as number[]
-    const iv = msg.slice(0, 32)
-    const ciphertextWithTag = msg.slice(32)
-    const messageTag = ciphertextWithTag.slice(-16)
-    const ciphertext = ciphertextWithTag.slice(0, -16)
-    const result = AESGCMDecrypt(
-      ciphertext,
-      [],
-      iv,
-      messageTag,
-      this.toArray()
-    )
-    if (result === null) {
-      throw new Error('Decryption failed!')
-    }
-    return encode(result, enc)
-  }
-}

package/src/primitives/TransactionSignature.ts

@@ -1,189 +0,0 @@
-import Signature from './Signature.js'
-import BigNumber from './BigNumber.js'
-import * as Hash from './Hash.js'
-import { toArray, Writer } from './utils.js'
-import Script from '../script/Script.js'
-import TransactionInput from '../transaction/TransactionInput.js'
-import TransactionOutput from '../transaction/TransactionOutput.js'
-
-export default class TransactionSignature extends Signature {
-  public static readonly SIGHASH_ALL = 0x00000001
-  public static readonly SIGHASH_NONE = 0x00000002
-  public static readonly SIGHASH_SINGLE = 0x00000003
-  public static readonly SIGHASH_FORKID = 0x00000040
-  public static readonly SIGHASH_ANYONECANPAY = 0x00000080
-
-  scope: number
-
-  static format(params: {
-    sourceTXID: string
-    sourceOutputIndex: number
-    sourceSatoshis: number
-    transactionVersion: number
-    otherInputs: TransactionInput[]
-    outputs: TransactionOutput[]
-    inputIndex: number
-    subscript: Script
-    inputSequence: number
-    lockTime: number
-    scope: number
-  }): number[] {
-    const currentInput = {
-      sourceTXID: params.sourceTXID,
-      sourceOutputIndex: params.sourceOutputIndex,
-      sequence: params.inputSequence
-    }
-    const inputs = [...params.otherInputs]
-    inputs.splice(params.inputIndex, 0, currentInput)
-
-    const getPrevoutHash = (): number[] => {
-      const writer = new Writer()
-      for (const input of inputs) {
-        if (typeof input.sourceTransaction === 'undefined') {
-          writer.writeReverse(toArray(input.sourceTXID, 'hex'))
-        } else {
-          writer.writeReverse(input.sourceTransaction.id() as number[])
-        }
-        writer.writeUInt32LE(input.sourceOutputIndex)
-      }
-
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf) as number[]
-      return ret
-    }
-
-    const getSequenceHash = (): number[] => {
-      const writer = new Writer()
-
-      for (const input of inputs) {
-        writer.writeUInt32LE(input.sequence)
-      }
-
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf) as number[]
-      return ret
-    }
-
-    function getOutputsHash(outputIndex?: number): number[] {
-      const writer = new Writer()
-
-      if (typeof outputIndex === 'undefined') {
-        let script: number[]
-        for (const output of params.outputs) {
-          writer.writeUInt64LE(output.satoshis)
-          script = output.lockingScript.toBinary()
-          writer.writeVarIntNum(script.length)
-          writer.write(script)
-        }
-      } else {
-        const output = params.outputs[outputIndex]
-        writer.writeUInt64LE(output.satoshis)
-        const script = output.lockingScript.toBinary()
-        writer.writeVarIntNum(script.length)
-        writer.write(script)
-      }
-
-      const buf = writer.toArray()
-      const ret = Hash.hash256(buf) as number[]
-      return ret
-    }
-
-    let hashPrevouts = new Array(32).fill(0)
-    let hashSequence = new Array(32).fill(0)
-    let hashOutputs = new Array(32).fill(0)
-
-    if ((params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0) {
-      hashPrevouts = getPrevoutHash()
-    }
-
-    if ((params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0 &&
-      (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
-      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
-      hashSequence = getSequenceHash()
-    }
-
-    if ((params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE && (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
-      hashOutputs = getOutputsHash()
-    } else if ((params.scope & 31) === TransactionSignature.SIGHASH_SINGLE && params.inputIndex < params.outputs.length) {
-      hashOutputs = getOutputsHash(params.inputIndex)
-    }
-
-    const writer = new Writer()
-
-    // Version
-    writer.writeInt32LE(params.transactionVersion)
-
-    // Input prevouts/nSequence (none/all, depending on flags)
-    writer.write(hashPrevouts)
-    writer.write(hashSequence)
-
-    //  outpoint (32-byte hash + 4-byte little endian)
-    writer.writeReverse(toArray(params.sourceTXID, 'hex'))
-    writer.writeUInt32LE(params.sourceOutputIndex)
-
-    // scriptCode of the input (serialized as scripts inside CTxOuts)
-    writer.writeVarIntNum(params.subscript.toBinary().length)
-    writer.write(params.subscript.toBinary())
-
-    // value of the output spent by this input (8-byte little endian)
-    writer.writeUInt64LE(params.sourceSatoshis)
-
-    // nSequence of the input (4-byte little endian)
-    const sequenceNumber = currentInput.sequence
-    writer.writeUInt32LE(sequenceNumber)
-
-    // Outputs (none/one/all, depending on flags)
-    writer.write(hashOutputs)
-
-    // Locktime
-    writer.writeUInt32LE(params.lockTime)
-
-    // sighashType
-    writer.writeUInt32LE(params.scope >>> 0)
-
-    const buf = writer.toArray()
-    return buf
-  }
-
-  // The format used in a tx
-  static fromChecksigFormat(buf: number[]): TransactionSignature {
-    if (buf.length === 0) {
-      // allow setting a "blank" signature
-      const r = new BigNumber(1)
-      const s = new BigNumber(1)
-      const scope = 1
-      return new TransactionSignature(r, s, scope)
-    }
-    const scope = buf[buf.length - 1]
-    const derbuf = buf.slice(0, buf.length - 1)
-    const tempSig = Signature.fromDER(derbuf)
-    return new TransactionSignature(tempSig.r, tempSig.s, scope)
-  }
-
-  constructor(r: BigNumber, s: BigNumber, scope: number) {
-    super(r, s)
-    this.scope = scope
-  }
-
-  /**
-     * Compares to bitcoind's IsLowDERSignature
-     * See also Ecdsa signature algorithm which enforces this.
-     * See also Bip 62, "low S values in signatures"
-     */
-  public hasLowS(): boolean {
-    if (
-      this.s.ltn(1) ||
-      this.s.gt(new BigNumber(
-        '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex'
-      ))
-    ) {
-      return false
-    }
-    return true
-  }
-
-  toChecksigFormat(): number[] {
-    const derbuf = this.toDER() as number[]
-    return [...derbuf, this.scope]
-  }
-}