@bsv/sdk 1.3.12 → 1.3.14

package/src/compat/HD.ts

@@ -1,4 +1,12 @@
-import { fromBase58Check, toBase58Check, Writer, Reader, toArray, toHex } from '../primitives/utils.js'
+// @ts-nocheck
+import {
+  fromBase58Check,
+  toBase58Check,
+  Writer,
+  Reader,
+  toArray,
+  toHex
+} from '../primitives/utils.js'
 import * as Hash from '../primitives/Hash.js'
 import Curve from '../primitives/Curve.js'
 import PrivateKey from '../primitives/PrivateKey.js'
@@ -30,16 +38,16 @@ export default class HD {
   }
 
   /**
-     * Constructor for the BIP32 HD wallet.
-     * Initializes an HD wallet with optional parameters for version bytes, depth, parent fingerprint, child index, chain code, private key, and public key.
-     * @param versionBytesNum - Version bytes number for the wallet.
-     * @param depth - Depth of the key in the hierarchy.
-     * @param parentFingerPrint - Fingerprint of the parent key.
-     * @param childIndex - Index of the child key.
-     * @param chainCode - Chain code for key derivation.
-     * @param privKey - Private key of the wallet.
-     * @param pubKey - Public key of the wallet.
-     */
+   * Constructor for the BIP32 HD wallet.
+   * Initializes an HD wallet with optional parameters for version bytes, depth, parent fingerprint, child index, chain code, private key, and public key.
+   * @param versionBytesNum - Version bytes number for the wallet.
+   * @param depth - Depth of the key in the hierarchy.
+   * @param parentFingerPrint - Fingerprint of the parent key.
+   * @param childIndex - Index of the child key.
+   * @param chainCode - Chain code for key derivation.
+   * @param privKey - Private key of the wallet.
+   * @param pubKey - Public key of the wallet.
+   */
   constructor (
     versionBytesNum?: number,
     depth?: number,
@@ -59,10 +67,10 @@ export default class HD {
   }
 
   /**
-     * Generates a new HD wallet with random keys.
-     * This method creates a root HD wallet with randomly generated private and public keys.
-     * @returns {HD} The current HD instance with generated keys.
-     */
+   * Generates a new HD wallet with random keys.
+   * This method creates a root HD wallet with randomly generated private and public keys.
+   * @returns {HD} The current HD instance with generated keys.
+   */
   public fromRandom (): this {
     this.versionBytesNum = this.constants.privKey
     this.depth = 0x00
@@ -75,11 +83,11 @@ export default class HD {
   }
 
   /**
-     * Generates a new HD wallet with random keys.
-     * This method creates a root HD wallet with randomly generated private and public keys.
-     * @returns {HD} A new HD instance with generated keys.
-     * @static
-     */
+   * Generates a new HD wallet with random keys.
+   * This method creates a root HD wallet with randomly generated private and public keys.
+   * @returns {HD} A new HD instance with generated keys.
+   * @static
+   */
   public static fromRandom (): HD {
     return new this().fromRandom()
   }
@@ -95,11 +103,11 @@ export default class HD {
   }
 
   /**
-     * Initializes the HD wallet from a given base58 encoded string.
-     * This method decodes a provided string to set up the HD wallet's properties.
-     * @param str - A base58 encoded string representing the wallet.
-     * @returns {HD} The current instance with properties set from the string.
-     */
+   * Initializes the HD wallet from a given base58 encoded string.
+   * This method decodes a provided string to set up the HD wallet's properties.
+   * @param str - A base58 encoded string representing the wallet.
+   * @returns {HD} The current instance with properties set from the string.
+   */
   public fromString (str: string): this {
     const decoded = fromBase58Check(str)
     return this.fromBinary([...decoded.prefix, ...decoded.data] as number[])
@@ -116,11 +124,11 @@ export default class HD {
   }
 
   /**
-     * Initializes the HD wallet from a seed.
-     * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
-     * @param bytes - An array of bytes representing the seed.
-     * @returns {HD} The current instance with properties set from the seed.
-     */
+   * Initializes the HD wallet from a seed.
+   * This method generates keys and other properties from a given seed, conforming to the BIP32 specification.
+   * @param bytes - An array of bytes representing the seed.
+   * @returns {HD} The current instance with properties set from the seed.
+   */
   public fromSeed (bytes: number[]): this {
     if (bytes.length < 128 / 8) {
       throw new Error('Need more than 128 bits of entropy')
@@ -128,7 +136,10 @@ export default class HD {
     if (bytes.length > 512 / 8) {
       throw new Error('More than 512 bits of entropy is nonstandard')
     }
-    const hash: number[] = Hash.sha512hmac(toArray('Bitcoin seed', 'utf8'), bytes)
+    const hash: number[] = Hash.sha512hmac(
+      toArray('Bitcoin seed', 'utf8'),
+      bytes
+    )
 
     this.depth = 0x00
     this.parentFingerPrint = [0, 0, 0, 0]
@@ -197,11 +208,11 @@ export default class HD {
   }
 
   /**
-     * Derives a child HD wallet based on a given path.
-     * The path specifies the hierarchy of the child key to be derived.
-     * @param path - A string representing the derivation path (e.g., 'm/0'/1).
-     * @returns {HD} A new HD instance representing the derived child wallet.
-     */
+   * Derives a child HD wallet based on a given path.
+   * The path specifies the hierarchy of the child key to be derived.
+   * @param path - A string representing the derivation path (e.g., 'm/0'/1).
+   * @returns {HD} A new HD instance representing the derived child wallet.
+   */
   public derive (path: string): HD {
     if (path === 'm') {
       return this
@@ -211,10 +222,8 @@ export default class HD {
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     let bip32: HD = this
-    for (const i in e) {
-      const c = e[i]
-
-      if (i === '0') {
+    for (const [i, c] of e.entries()) {
+      if (i === 0) { // Since `i` is now a number, compare it to 0
         if (c !== 'm') {
           throw new Error('invalid path')
         }
@@ -226,7 +235,8 @@ export default class HD {
       }
 
       const usePrivate = c.length > 1 && c[c.length - 1] === "'"
-      let childIndex = parseInt(usePrivate ? c.slice(0, c.length - 1) : c, 10) & 0x7fffffff
+      let childIndex =
+        parseInt(usePrivate ? c.slice(0, c.length - 1) : c, 10) & 0x7fffffff
 
       if (usePrivate) {
         childIndex += 0x80000000
@@ -239,11 +249,11 @@ export default class HD {
   }
 
   /**
-     * Derives a child HD wallet from the current wallet based on an index.
-     * This method generates either a private or public child key depending on the current wallet's state.
-     * @param i - The index of the child key to derive.
-     * @returns {HD} A new HD instance representing the derived child wallet.
-     */
+   * Derives a child HD wallet from the current wallet based on an index.
+   * This method generates either a private or public child key depending on the current wallet's state.
+   * @param i - The index of the child key to derive.
+   * @returns {HD} A new HD instance representing the derived child wallet.
+   */
   public deriveChild (i: number): HD {
     if (typeof i !== 'number') {
       throw new Error('i must be a number')
@@ -260,18 +270,18 @@ export default class HD {
 
     const isPrivate = this.versionBytesNum === this.constants.privKey
 
-    if (usePrivate && (!this.privKey || !isPrivate)) {
+    if (usePrivate && (this.privKey === null || this.privKey === undefined || !isPrivate)) {
       throw new Error('Cannot do private key derivation without private key')
     }
 
     let ret = null
-    if (this.privKey) {
+    if (this.privKey !== null && this.privKey !== undefined) {
       let data = null
 
       if (usePrivate) {
         data = [0, ...this.privKey.toArray('be', 32), ...ib]
       } else {
-        data = [...this.pubKey.encode(true) as number[], ...ib]
+        data = [...(this.pubKey.encode(true) as number[]), ...ib]
       }
 
       const hash = Hash.sha512hmac(this.chainCode, data)
@@ -287,7 +297,7 @@ export default class HD {
       ret.privKey = new PrivateKey(k.toArray())
       ret.pubKey = ret.privKey.toPublicKey()
     } else {
-      const data = [...this.pubKey.encode(true) as number[], ...ib]
+      const data = [...(this.pubKey.encode(true) as number[]), ...ib]
       const hash = Hash.sha512hmac(this.chainCode, data)
       const il = new BigNumber(hash.slice(0, 32))
       const ir = hash.slice(32, 64)
@@ -314,22 +324,30 @@ export default class HD {
   }
 
   /**
-     * Converts the current HD wallet to a public-only wallet.
-     * This method strips away the private key information, leaving only the public part.
-     * @returns {HD} A new HD instance representing the public-only wallet.
-     */
+   * Converts the current HD wallet to a public-only wallet.
+   * This method strips away the private key information, leaving only the public part.
+   * @returns {HD} A new HD instance representing the public-only wallet.
+   */
   public toPublic (): HD {
-    const bip32 = new HD(this.versionBytesNum, this.depth, this.parentFingerPrint, this.childIndex, this.chainCode, this.privKey, this.pubKey)
+    const bip32 = new HD(
+      this.versionBytesNum,
+      this.depth,
+      this.parentFingerPrint,
+      this.childIndex,
+      this.chainCode,
+      this.privKey,
+      this.pubKey
+    )
     bip32.versionBytesNum = this.constants.pubKey
     bip32.privKey = undefined
     return bip32
   }
 
   /**
-     * Converts the HD wallet into a binary representation.
-     * This method serializes the wallet's properties into a binary format.
-     * @returns {number[]} An array of numbers representing the binary data of the wallet.
-     */
+   * Converts the HD wallet into a binary representation.
+   * This method serializes the wallet's properties into a binary format.
+   * @returns {number[]} An array of numbers representing the binary data of the wallet.
+   */
   public toBinary (): number[] {
     const isPrivate = this.versionBytesNum === this.constants.privKey
     const isPublic = this.versionBytesNum === this.constants.pubKey
@@ -358,10 +376,10 @@ export default class HD {
   }
 
   /**
-     * Checks if the HD wallet contains a private key.
-     * This method determines whether the wallet is a private key wallet or a public key only wallet.
-     * @returns {boolean} A boolean value indicating whether the wallet has a private key (true) or not (false).
-     */
+   * Checks if the HD wallet contains a private key.
+   * This method determines whether the wallet is a private key wallet or a public key only wallet.
+   * @returns {boolean} A boolean value indicating whether the wallet has a private key (true) or not (false).
+   */
   public isPrivate (): boolean {
     return this.versionBytesNum === this.constants.privKey
   }

package/src/compat/Mnemonic.ts

@@ -18,31 +18,31 @@ export default class Mnemonic {
   public Wordlist: { value: string[], space: string }
 
   /**
-     * Constructs a Mnemonic object.
-     * @param {string} [mnemonic] - An optional mnemonic phrase.
-     * @param {number[]} [seed] - An optional seed derived from the mnemonic.
-     * @param {object} [wordlist=wordList] - An object containing a list of words and space character used in the mnemonic.
-     */
+   * Constructs a Mnemonic object.
+   * @param {string} [mnemonic] - An optional mnemonic phrase.
+   * @param {number[]} [seed] - An optional seed derived from the mnemonic.
+   * @param {object} [wordlist=wordList] - An object containing a list of words and space character used in the mnemonic.
+   */
   constructor (mnemonic?: string, seed?: number[], wordlist = wordList) {
-    this.mnemonic = mnemonic
-    this.seed = seed
+    this.mnemonic = mnemonic ?? '' // Default to empty string if undefined
+    this.seed = seed ?? [] // Default to empty array if undefined
     this.Wordlist = wordlist
   }
 
   /**
-     * Converts the mnemonic and seed into a binary representation.
-     * @returns {number[]} The binary representation of the mnemonic and seed.
-     */
+   * Converts the mnemonic and seed into a binary representation.
+   * @returns {number[]} The binary representation of the mnemonic and seed.
+   */
   public toBinary (): number[] {
     const bw = new Writer()
-    if (this.mnemonic) {
+    if (this.mnemonic !== '') {
       const buf = toArray(this.mnemonic, 'utf8')
       bw.writeVarIntNum(buf.length)
       bw.write(buf)
     } else {
       bw.writeVarIntNum(0)
     }
-    if (this.seed) {
+    if (this.seed.length > 0) {
       bw.writeVarIntNum(this.seed.length)
       bw.write(this.seed)
     } else {
@@ -52,10 +52,10 @@ export default class Mnemonic {
   }
 
   /**
-     * Loads a mnemonic and seed from a binary representation.
-     * @param {number[]} bin - The binary representation of a mnemonic and seed.
-     * @returns {this} The Mnemonic instance with loaded mnemonic and seed.
-     */
+   * Loads a mnemonic and seed from a binary representation.
+   * @param {number[]} bin - The binary representation of a mnemonic and seed.
+   * @returns {this} The Mnemonic instance with loaded mnemonic and seed.
+   */
   public fromBinary (bin: number[]): this {
     const br = new Reader(bin)
     const mnemoniclen = br.readVarIntNum()
@@ -70,13 +70,13 @@ export default class Mnemonic {
   }
 
   /**
-     * Generates a random mnemonic from a given bit length.
-     * @param {number} [bits=128] - The bit length for the random mnemonic (must be a multiple of 32 and at least 128).
-     * @returns {this} The Mnemonic instance with the new random mnemonic.
-     * @throws {Error} If the bit length is not a multiple of 32 or is less than 128.
-     */
+   * Generates a random mnemonic from a given bit length.
+   * @param {number} [bits=128] - The bit length for the random mnemonic (must be a multiple of 32 and at least 128).
+   * @returns {this} The Mnemonic instance with the new random mnemonic.
+   * @throws {Error} If the bit length is not a multiple of 32 or is less than 128.
+   */
   public fromRandom (bits?: number): this {
-    if (!bits) {
+    if (bits === undefined || bits === null || isNaN(bits) || bits === 0) {
       bits = 128
     }
     if (bits % 32 !== 0) {
@@ -92,86 +92,88 @@ export default class Mnemonic {
   }
 
   /**
-     * Static method to generate a Mnemonic instance with a random mnemonic.
-     * @param {number} [bits=128] - The bit length for the random mnemonic.
-     * @returns {Mnemonic} A new Mnemonic instance.
-     */
+   * Static method to generate a Mnemonic instance with a random mnemonic.
+   * @param {number} [bits=128] - The bit length for the random mnemonic.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
   public static fromRandom (bits?: number): Mnemonic {
     return new this().fromRandom(bits)
   }
 
   /**
-     * Converts given entropy into a mnemonic phrase.
-     * This method is used to generate a mnemonic from a specific entropy source.
-     * @param {number[]} buf - The entropy buffer, must be at least 128 bits.
-     * @returns {this} The Mnemonic instance with the mnemonic set from the given entropy.
-     * @throws {Error} If the entropy is less than 128 bits.
-     */
+   * Converts given entropy into a mnemonic phrase.
+   * This method is used to generate a mnemonic from a specific entropy source.
+   * @param {number[]} buf - The entropy buffer, must be at least 128 bits.
+   * @returns {this} The Mnemonic instance with the mnemonic set from the given entropy.
+   * @throws {Error} If the entropy is less than 128 bits.
+   */
   public fromEntropy (buf: number[]): this {
     this.entropy2Mnemonic(buf)
     return this
   }
 
   /**
-     * Static method to create a Mnemonic instance from a given entropy.
-     * @param {number[]} buf - The entropy buffer.
-     * @returns {Mnemonic} A new Mnemonic instance.
-     */
+   * Static method to create a Mnemonic instance from a given entropy.
+   * @param {number[]} buf - The entropy buffer.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
   public static fromEntropy (buf: number[]): Mnemonic {
     return new this().fromEntropy(buf)
   }
 
   /**
-     * Sets the mnemonic for the instance from a string.
-     * @param {string} mnemonic - The mnemonic phrase as a string.
-     * @returns {this} The Mnemonic instance with the set mnemonic.
-     */
+   * Sets the mnemonic for the instance from a string.
+   * @param {string} mnemonic - The mnemonic phrase as a string.
+   * @returns {this} The Mnemonic instance with the set mnemonic.
+   */
   public fromString (mnemonic: string): this {
     this.mnemonic = mnemonic
     return this
   }
 
   /**
-     * Static method to create a Mnemonic instance from a mnemonic string.
-     * @param {string} str - The mnemonic phrase.
-     * @returns {Mnemonic} A new Mnemonic instance.
-     */
+   * Static method to create a Mnemonic instance from a mnemonic string.
+   * @param {string} str - The mnemonic phrase.
+   * @returns {Mnemonic} A new Mnemonic instance.
+   */
   public static fromString (str: string): Mnemonic {
     return new this().fromString(str)
   }
 
   /**
-     * Converts the instance's mnemonic to a string representation.
-     * @returns {string} The mnemonic phrase as a string.
-     */
+   * Converts the instance's mnemonic to a string representation.
+   * @returns {string} The mnemonic phrase as a string.
+   */
   public toString (): string {
     return this.mnemonic
   }
 
   /**
-     * Converts the mnemonic to a seed.
-     * The mnemonic must pass the validity check before conversion.
-     * @param {string} [passphrase=''] - An optional passphrase for additional security.
-     * @returns {number[]} The generated seed.
-     * @throws {Error} If the mnemonic is invalid.
-     */
+   * Converts the mnemonic to a seed.
+   * The mnemonic must pass the validity check before conversion.
+   * @param {string} [passphrase=''] - An optional passphrase for additional security.
+   * @returns {number[]} The generated seed.
+   * @throws {Error} If the mnemonic is invalid.
+   */
   public toSeed (passphrase?: string): number[] {
     this.mnemonic2Seed(passphrase)
     return this.seed
   }
 
   /**
-     * Converts entropy to a mnemonic phrase.
-     * This method takes a buffer of entropy and converts it into a corresponding
-     * mnemonic phrase based on the Mnemonic wordlist. The entropy should be at least 128 bits.
-     * The method applies a checksum and maps the entropy to words in the wordlist.
-     * @param {number[]} buf - The entropy buffer to convert. Must be at least 128 bits.
-     * @returns {this} The Mnemonic instance with the mnemonic set from the entropy.
-     * @throws {Error} If the entropy is less than 128 bits or if it's not an even multiple of 11 bits.
-     */
+   * Converts entropy to a mnemonic phrase.
+   * This method takes a buffer of entropy and converts it into a corresponding
+   * mnemonic phrase based on the Mnemonic wordlist. The entropy should be at least 128 bits.
+   * The method applies a checksum and maps the entropy to words in the wordlist.
+   * @param {number[]} buf - The entropy buffer to convert. Must be at least 128 bits.
+   * @returns {this} The Mnemonic instance with the mnemonic set from the entropy.
+   * @throws {Error} If the entropy is less than 128 bits or if it's not an even multiple of 11 bits.
+   */
   public entropy2Mnemonic (buf: number[]): this {
     if (buf.length < 128 / 8) {
-      throw new Error('Entropy is less than 128 bits. It must be 128 bits or more.')
+      throw new Error(
+        'Entropy is less than 128 bits. It must be 128 bits or more.'
+      )
     }
 
     const hash = Hash.sha256(buf)
@@ -185,7 +187,10 @@ export default class Mnemonic {
     bin = bin + hashbits
 
     if (bin.length % 11 !== 0) {
-      throw new Error('internal error - entropy not an even multiple of 11 bits - ' + bin.length)
+      throw new Error(
+        'internal error - entropy not an even multiple of 11 bits - ' +
+        bin.length.toString()
+      )
     }
 
     let mnemonic = ''
@@ -202,11 +207,11 @@ export default class Mnemonic {
   }
 
   /**
-     * Validates the mnemonic phrase.
-     * Checks for correct length, absence of invalid words, and proper checksum.
-     * @returns {boolean} True if the mnemonic is valid, false otherwise.
-     * @throws {Error} If the mnemonic is not an even multiple of 11 bits.
-     */
+   * Validates the mnemonic phrase.
+   * Checks for correct length, absence of invalid words, and proper checksum.
+   * @returns {boolean} True if the mnemonic is valid, false otherwise.
+   * @throws {Error} If the mnemonic is not an even multiple of 11 bits.
+   */
   public check (): boolean {
     const mnemonic = this.mnemonic
 
@@ -222,14 +227,18 @@ export default class Mnemonic {
     }
 
     if (bin.length % 11 !== 0) {
-      throw new Error('internal error - entropy not an even multiple of 11 bits - ' + bin.length)
+      throw new Error(
+        'internal error - entropy not an even multiple of 11 bits - ' +
+        bin.length.toString()
+      )
     }
 
     // confirm checksum
     const cs = bin.length / 33
     const hashBits = bin.slice(-cs)
     const nonhashBits = bin.slice(0, bin.length - cs)
-    const buf = []
+    const buf: number[] = []
+
     for (let i = 0; i < nonhashBits.length / 8; i++) {
       buf.push(parseInt(bin.slice(i * 8, (i + 1) * 8), 2))
     }
@@ -241,14 +250,14 @@ export default class Mnemonic {
   }
 
   /**
-     * Converts a mnemonic to a seed.
-     * This method takes the instance's mnemonic phrase, combines it with a passphrase (if provided),
-     * and uses PBKDF2 to generate a seed. It also validates the mnemonic before conversion.
-     * This seed can then be used for generating deterministic keys.
-     * @param {string} [passphrase=''] - An optional passphrase for added security.
-     * @returns {this} The Mnemonic instance with the seed generated from the mnemonic.
-     * @throws {Error} If the mnemonic does not pass validation or if the passphrase is not a string.
-     */
+   * Converts a mnemonic to a seed.
+   * This method takes the instance's mnemonic phrase, combines it with a passphrase (if provided),
+   * and uses PBKDF2 to generate a seed. It also validates the mnemonic before conversion.
+   * This seed can then be used for generating deterministic keys.
+   * @param {string} [passphrase=''] - An optional passphrase for added security.
+   * @returns {this} The Mnemonic instance with the seed generated from the mnemonic.
+   * @throws {Error} If the mnemonic does not pass validation or if the passphrase is not a string.
+   */
   public mnemonic2Seed (passphrase = ''): this {
     let mnemonic = this.mnemonic
     if (!this.check()) {
@@ -262,33 +271,37 @@ export default class Mnemonic {
     mnemonic = mnemonic.normalize('NFKD')
     passphrase = passphrase.normalize('NFKD')
     const mbuf = toArray(mnemonic, 'utf8')
-    const pbuf = [...toArray('mnemonic', 'utf8'), ...toArray(passphrase, 'utf8')]
+    const pbuf = [
+      ...toArray('mnemonic', 'utf8'),
+      ...toArray(passphrase, 'utf8')
+    ]
     this.seed = Hash.pbkdf2(mbuf, pbuf, 2048, 64, 'sha512')
     return this
   }
 
   /**
-     * Determines the validity of a given passphrase with the mnemonic.
-     * This method is useful for checking if a passphrase matches with the mnemonic.
-     * @param {string} [passphrase=''] - The passphrase to validate.
-     * @returns {boolean} True if the mnemonic and passphrase combination is valid, false otherwise.
-     */
+   * Determines the validity of a given passphrase with the mnemonic.
+   * This method is useful for checking if a passphrase matches with the mnemonic.
+   * @param {string} [passphrase=''] - The passphrase to validate.
+   * @returns {boolean} True if the mnemonic and passphrase combination is valid, false otherwise.
+   */
   public isValid (passphrase = ''): boolean {
     let isValid
     try {
-      isValid = !!this.mnemonic2Seed(passphrase)
-    } catch (err) {
+      this.mnemonic2Seed(passphrase)
+      isValid = true
+    } catch {
       isValid = false
     }
     return isValid
   }
 
   /**
-     * Static method to check the validity of a given mnemonic and passphrase combination.
-     * @param {string} mnemonic - The mnemonic phrase.
-     * @param {string} [passphrase=''] - The passphrase to validate.
-     * @returns {boolean} True if the combination is valid, false otherwise.
-     */
+   * Static method to check the validity of a given mnemonic and passphrase combination.
+   * @param {string} mnemonic - The mnemonic phrase.
+   * @param {string} [passphrase=''] - The passphrase to validate.
+   * @returns {boolean} True if the combination is valid, false otherwise.
+   */
   public static isValid (mnemonic: string, passphrase = ''): boolean {
     return new Mnemonic(mnemonic).isValid(passphrase)
   }

package/src/compat/Utxo.ts

@@ -36,10 +36,13 @@ interface jsonUtxo {
  * @param unlockingScriptTemplate: { sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>, estimateLength: (tx: Transaction, inputIndex: number) => Promise<number> }
  * @returns
  */
-export default function fromUtxo (utxo: jsonUtxo, unlockingScriptTemplate: {
-  sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-  estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
-}): TransactionInput {
+export default function fromUtxo (
+  utxo: jsonUtxo,
+  unlockingScriptTemplate: {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
+  }
+): TransactionInput {
   const sourceTransaction = new Transaction(0, [], [], 0)
   sourceTransaction.outputs = Array(utxo.vout + 1).fill(null)
   sourceTransaction.outputs[utxo.vout] = {
@@ -51,6 +54,6 @@ export default function fromUtxo (utxo: jsonUtxo, unlockingScriptTemplate: {
     sourceTXID: utxo.txid,
     sourceOutputIndex: utxo.vout,
     unlockingScriptTemplate,
-    sequence: 0xFFFFFFFF
+    sequence: 0xffffffff
   }
 }