@bsv/sdk 1.0.4 → 1.0.5

package/docs/script.md

@@ -611,7 +611,7 @@ This class provides methods to create Pay To Public Key Hash locking and unlocki
 
 ```ts
 export default class P2PKH implements ScriptTemplate {
-    lock(pubkeyhash: number[]): LockingScript 
+    lock(pubkeyhash: string | number[]): LockingScript 
     unlock(privateKey: PrivateKey, signOutputs: "all" | "none" | "single" = "all", anyoneCanPay: boolean = false): {
         sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
         estimateLength: () => Promise<106>;
@@ -625,10 +625,10 @@ export default class P2PKH implements ScriptTemplate {
 
 #### Method lock
 
-Creates a P2PKH locking script for a given public key hash.
+Creates a P2PKH locking script for a given public key hash or address string
 
 ```ts
-lock(pubkeyhash: number[]): LockingScript 
+lock(pubkeyhash: string | number[]): LockingScript 
 ```
 
 Returns
@@ -638,7 +638,7 @@ Returns
 Argument Details
 
 + **pubkeyhash**
-  + An array representing the public key hash.
+  + or address - An array or address representing the public key hash.
 
 #### Method unlock
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "type": "module",
   "description": "BSV Blockchain Standard Development Kit",
   "main": "dist/cjs/mod.js",

package/src/primitives/BigNumber.ts

@@ -194,6 +194,7 @@ export default class BigNumber {
     base: number | 'be' | 'le' | 'hex' = 10,
     endian: 'be' | 'le' = 'be'
   ) {
+
     this.negative = 0
     this.words = []
     this.length = 0
@@ -634,7 +635,7 @@ export default class BigNumber {
    * @returns - Returns the BigNumber after stripping leading zeros.
    *
    * @example
-   * const bn = new BigNumber('000000", 2, "be");
+   * const bn = new BigNumber("000000", 2, "be");
    * bn.strip();
    * // bn now represents 0
    */

package/src/primitives/Hash.ts

@@ -68,7 +68,11 @@ abstract class BaseHash {
     throw new Error('Not implemented')
   }
 
-  _digest(enc?: 'hex'): number[] | string {
+  _digest(): number[] {
+    throw new Error('Not implemented')
+  }
+
+  _digestHex(): string {
     throw new Error('Not implemented')
   }
 
@@ -85,7 +89,7 @@ abstract class BaseHash {
    * @example
    * sha256.update('Hello World', 'utf8');
    */
-  update(msg: number[] | string, enc?: 'hex'): this {
+  update(msg: number[] | string, enc?: 'hex' | 'utf8'): this {
     // Convert message to array, pad it, and join into 32bit blocks
     msg = toArray(msg, enc)
     if (this.pending == null) {
@@ -117,18 +121,34 @@ abstract class BaseHash {
    * Finalizes the hash computation and returns the hash value/result.
    *
    * @method digest
-   * @param enc - The encoding of the final hash. If 'hex' then a hex string will be provided, otherwise an array of numbers.
    *
    * @returns Returns the final hash value.
    *
    * @example
-   * const hash = sha256.digest('hex');
+   * const hash = sha256.digest();
    */
-  digest(enc?: 'hex'): number[] | string {
+  digest(): number[] {
     this.update(this._pad())
     assert(this.pending === null)
 
-    return this._digest(enc)
+    return this._digest()
+  };
+
+  /**
+   * Finalizes the hash computation and returns the hash value/result as a hex string.
+   *
+   * @method digest
+   *
+   * @returns Returns the final hash value as a hex string.
+   *
+   * @example
+   * const hash = sha256.digestHex();
+   */
+  digestHex(): string {
+    this.update(this._pad())
+    assert(this.pending === null)
+    
+    return this._digestHex()
   };
 
   /**
@@ -189,7 +209,13 @@ function isSurrogatePair(msg: string, i: number): boolean {
   return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00
 }
 
-export function toArray(msg: number[] | string, enc?: 'hex'): number[] {
+/**
+ * 
+ * @param msg 
+ * @param enc Optional. Encoding to use if msg is string. Default is 'utf8'.
+ * @returns array of byte values from msg. If msg is an array, a copy is returned.
+ */
+export function toArray(msg: number[] | string, enc?: 'hex' | 'utf8'): number[] {
   if (Array.isArray(msg)) { return msg.slice() }
   if (!(msg as unknown as boolean)) { return [] }
   const res = []
@@ -563,12 +589,12 @@ export class RIPEMD160 extends BaseHash {
     this.h[0] = T
   }
 
-  _digest(enc?: 'hex'): string | number[] {
-    if (enc === 'hex') {
-      return toHex32(this.h, 'little')
-    } else {
+  _digest(): number[] {
       return split32(this.h, 'little')
-    }
+  }
+
+  _digestHex(): string {
+      return toHex32(this.h, 'little')
   }
 }
 
@@ -667,12 +693,12 @@ export class SHA256 extends BaseHash {
     this.h[7] = sum32(this.h[7], h)
   };
 
-  _digest(enc?: 'hex'): number[] | string {
-    if (enc === 'hex') {
-      return toHex32(this.h, 'big')
-    } else {
-      return split32(this.h, 'big')
-    }
+  _digest(): number[] {
+    return split32(this.h, 'big')
+  }
+
+  _digestHex(): string {
+    return toHex32(this.h, 'big')
   }
 }
 
@@ -745,12 +771,12 @@ export class SHA1 extends BaseHash {
     this.h[4] = sum32(this.h[4], e)
   }
 
-  _digest(enc?: 'hex'): number[] | string {
-    if (enc === 'hex') {
-      return toHex32(this.h, 'big')
-    } else {
-      return split32(this.h, 'big')
-    }
+  _digest(): number[] {
+    return split32(this.h, 'big')
+  }
+
+  _digestHex(): string {
+    return toHex32(this.h, 'big')
   }
 }
 
@@ -956,11 +982,12 @@ export class SHA512 extends BaseHash {
     sum64(this.h, 14, hh, hl);
   }
 
-  _digest(enc) {
-    if (enc === 'hex')
-      return toHex32(this.h, 'big');
-    else
-      return split32(this.h, 'big');
+  _digest() {
+    return split32(this.h, 'big');
+  }
+
+  _digestHex() {
+    return toHex32(this.h, 'big');
   }
 }
 
@@ -1151,15 +1178,28 @@ export class SHA256HMAC {
    * Finalizes the HMAC computation and returns the resultant hash.
    *
    * @method digest
-   * @param enc - If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
    * @returns Returns the digest of the hashed data. Can be a number array or a string.
    *
    * @example
-   * let hashedMessage = myHMAC.digest('hex');
+   * let hashedMessage = myHMAC.digest();
    */
-  digest(enc?: 'hex'): number[] | string {
-    this.outer.update(this.inner.digest() as number[])
-    return this.outer.digest(enc)
+  digest(): number[] {
+    this.outer.update(this.inner.digest())
+    return this.outer.digest()
+  }
+
+  /**
+   * Finalizes the HMAC computation and returns the resultant hash as a hex string.
+   *
+   * @method digest
+   * @returns Returns the digest of the hashed data as a hex string
+   *
+   * @example
+   * let hashedMessage = myHMAC.digestHex();
+   */
+  digestHex(): string {
+    this.outer.update(this.inner.digest())
+    return this.outer.digestHex()
   }
 }
 
@@ -1225,7 +1265,7 @@ export class SHA512HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update(msg: number[] | string, enc?: 'hex'): SHA512HMAC {
+  update(msg: number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC {
     this.inner.update(msg, enc)
     return this
   }
@@ -1234,76 +1274,90 @@ export class SHA512HMAC {
    * Finalizes the HMAC computation and returns the resultant hash.
    *
    * @method digest
-   * @param enc - If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
-   * @returns Returns the digest of the hashed data. Can be a number array or a string.
+   * @returns Returns the digest of the hashed data as a number array.
    *
    * @example
-   * let hashedMessage = myHMAC.digest('hex');
+   * let hashedMessage = myHMAC.digest();
    */
-  digest(enc?: 'hex'): number[] | string {
+  digest(): number[] {
     this.outer.update(this.inner.digest() as number[])
-    return this.outer.digest(enc)
+    return this.outer.digest()
   }
+
+  /**
+   * Finalizes the HMAC computation and returns the resultant hash as a hex string.
+   *
+   * @method digest
+   * @returns Returns the digest of the hashed data as a hex string
+   *
+   * @example
+   * let hashedMessage = myHMAC.digestHex();
+   */
+  digestHex(): string {
+    this.outer.update(this.inner.digest() as number[])
+    return this.outer.digestHex()
+  }
+
 }
 
 /**
  * Computes RIPEMD160 hash of a given message.
  * @function ripemd160
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed RIPEMD160 hash of the message.
  *
  * @example
  * const digest = ripemd160('Hello, world!');
  */
-export const ripemd160 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new RIPEMD160().update(msg, enc).digest(enc)
+export const ripemd160 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
+  return new RIPEMD160().update(msg, enc).digest()
 }
 
 /**
  * Computes SHA1 hash of a given message.
  * @function sha1
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed SHA1 hash of the message.
  *
  * @example
  * const digest = sha1('Hello, world!');
  */
-export const sha1 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new SHA1().update(msg, enc).digest(enc)
+export const sha1 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
+  return new SHA1().update(msg, enc).digest()
 }
 
 /**
  * Computes SHA256 hash of a given message.
  * @function sha256
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed SHA256 hash of the message.
  *
  * @example
  * const digest = sha256('Hello, world!');
  */
-export const sha256 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new SHA256().update(msg, enc).digest(enc)
+export const sha256 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
+  return new SHA256().update(msg, enc).digest()
 }
 
 /**
  * Computes SHA512 hash of a given message.
  * @function sha512
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed SHA512 hash of the message.
  *
  * @example
  * const digest = sha512('Hello, world!');
  */
-export const sha512 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new SHA512().update(msg, enc).digest(enc)
+export const sha512 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
+  return new SHA512().update(msg, enc).digest()
 }
 
 /**
@@ -1312,16 +1366,16 @@ export const sha512 = (msg: number[] | string, enc?: 'hex'): number[] | string =
  * SHA256 hash of the resulting hash is computed.
  * @function hash256
  * @param msg - The message to compute the hash for.
- * @param enc - Encoding of the message.If 'hex', the message is decoded from hexadecimal.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the double hashed SHA256 output.
  *
  * @example
  * const doubleHash = hash256('Hello, world!');
  */
-export const hash256 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
+export const hash256 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
   const first = new SHA256().update(msg, enc).digest()
-  return new SHA256().update(first).digest(enc)
+  return new SHA256().update(first).digest()
 }
 
 /**
@@ -1329,16 +1383,16 @@ export const hash256 = (msg: number[] | string, enc?: 'hex'): number[] | string
  *
  * @function hash160
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the RIPEMD160 hash of the SHA256 hash of the input message.
  *
  * @example
  * const hash = hash160('Hello, world!');
  */
-export const hash160 = (msg: number[] | string, enc?: 'hex'): number[] | string => {
+export const hash160 = (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] => {
   const first = new SHA256().update(msg, enc).digest()
-  return new RIPEMD160().update(first).digest(enc)
+  return new RIPEMD160().update(first).digest()
 }
 
 /**
@@ -1346,15 +1400,15 @@ export const hash160 = (msg: number[] | string, enc?: 'hex'): number[] | string
  * @function sha256hmac
  * @param key - The key used to compute the HMAC
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed HMAC of the message.
  *
  * @example
  * const digest = sha256hmac('deadbeef', 'ffff001d');
  */
-export const sha256hmac = (key: number[] | string, msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new SHA256HMAC(key).update(msg, enc).digest(enc)
+export const sha256hmac = (key: number[] | string, msg: number[] | string, enc?: 'hex'): number[] => {
+  return new SHA256HMAC(key).update(msg, enc).digest()
 }
 
 /**
@@ -1362,15 +1416,15 @@ export const sha256hmac = (key: number[] | string, msg: number[] | string, enc?:
  * @function sha512hmac
  * @param key - The key used to compute the HMAC
  * @param msg - The message to compute the hash for.
- * @param enc - The encoding of the message. If 'hex', the message is decoded from hexadecimal first.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
  *
  * @returns the computed HMAC of the message.
  *
  * @example
  * const digest = sha512hmac('deadbeef', 'ffff001d');
  */
-export const sha512hmac = (key: number[] | string, msg: number[] | string, enc?: 'hex'): number[] | string => {
-  return new SHA512HMAC(key).update(msg, enc).digest(enc)
+export const sha512hmac = (key: number[] | string, msg: number[] | string, enc?: 'hex'): number[] => {
+  return new SHA512HMAC(key).update(msg, enc).digest()
 }
 
 /**

package/src/primitives/PrivateKey.ts

@@ -67,6 +67,33 @@ export default class PrivateKey extends BigNumber {
     return new PrivateKey(decoded.data.slice(0, 32))
   }
 
+  /**
+   * @constructor
+   *
+   * @param number - The number (various types accepted) to construct a BigNumber from. Default is 0.
+   *
+   * @param base - The base of number provided. By default is 10. Ignored if number is BigNumber.
+   *
+   * @param endian - The endianness provided. By default is 'big endian'. Ignored if number is BigNumber.
+   *
+   * @example
+   * import PrivateKey from './PrivateKey';
+   * import BigNumber from './BigNumber';
+   * const privKey = new PrivateKey(new BigNumber('123456', 10, 'be'));
+   */
+  constructor (
+    number: BigNumber | number | string | number[] = 0,
+    base: number | 'be' | 'le' | 'hex' = 10,
+    endian: 'be' | 'le' = 'be'
+  ) {
+    if (number instanceof BigNumber) {
+      super()
+      number.copy(this)
+    } else {
+      super(number, base, endian)
+    }
+  }
+
   /**
    * Signs a message using the private key.
    *
@@ -81,7 +108,7 @@ export default class PrivateKey extends BigNumber {
    * const privateKey = PrivateKey.fromRandom();
    * const signature = privateKey.sign('Hello, World!');
    */
-  sign (msg: number[] | string, enc?: 'hex', forceLowS: boolean = true, customK?: Function | BigNumber): Signature {
+  sign (msg: number[] | string, enc?: 'hex' | 'utf8', forceLowS: boolean = true, customK?: Function | BigNumber): Signature {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return sign(msgHash, this, forceLowS, customK)
   }

package/src/primitives/PublicKey.ts

@@ -52,6 +52,28 @@ export default class PublicKey extends Point {
     return new PublicKey(p.x, p.y)
   }
 
+  /**
+   * @constructor
+   * @param x - A point or the x-coordinate of the point. May be a number, a BigNumber, a string (which will be interpreted as hex), a number array, or null. If null, an "Infinity" point is constructed.
+   * @param y - If x is not a point, the y-coordinate of the point, similar to x.
+   * @param isRed - A boolean indicating if the point is a member of the field of integers modulo the k256 prime. Default is true.
+   *
+   * @example
+   * new PublicKey(point1);
+   * new PublicKey('abc123', 'def456');
+   */
+  constructor (
+    x: Point | BigNumber | number | number[] | string | null,
+    y: BigNumber | number | number[] | string | null = null,
+    isRed: boolean = true
+  ) {
+    if (x instanceof Point) {
+      super(x.getX(), x.getY())
+    } else {
+      super(x, y, isRed)
+    }
+  }
+
   /**
    * Derive a shared secret from a public key and a private key for use in symmetric encryption.
    * This method multiplies the public key (an instance of Point) with a private key.
@@ -78,7 +100,7 @@ export default class PublicKey extends Point {
    *
    * @param msg - The message to verify. It can be a string or an array of numbers.
    * @param sig - The Signature of the message that needs verification.
-   * @param enc - The encoding of the message. It defaults to 'hex'.
+   * @param enc - The encoding of the message. It defaults to 'utf8'.
    *
    * @returns Returns true if the signature is verified successfully, otherwise false.
    *
@@ -87,7 +109,7 @@ export default class PublicKey extends Point {
    * const mySignature = new Signature(...)
    * const isVerified = myPubKey.verify(myMessage, mySignature)
    */
-  verify (msg: number[] | string, sig: Signature, enc?: 'hex'): boolean {
+  verify (msg: number[] | string, sig: Signature, enc?: 'hex' | 'utf8'): boolean {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return verify(msgHash, sig, this)
   }

package/src/primitives/SymmetricKey.ts

@@ -12,6 +12,20 @@ import { toArray, encode } from './utils.js'
  * @extends {BigNumber}
  */
 export default class SymmetricKey extends BigNumber {
+  /**
+   * Generates a symmetric key randomly.
+   *
+   * @method fromRandom
+   * @static
+   * @returns The newly generated Symmetric Key.
+   *
+   * @example
+   * const symmetricKey = SymmetricKey.fromRandom();
+   */
+  static fromRandom(): SymmetricKey {
+    return new SymmetricKey(Random(32))
+  }
+
   /**
   * Encrypts a given message using AES-GCM encryption.
   * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
@@ -26,14 +40,14 @@ export default class SymmetricKey extends BigNumber {
   * const key = new SymmetricKey(1234);
   * const encryptedMessage = key.encrypt('plainText', 'utf8');
   */
-  encrypt (msg: number[] | string, enc?: 'hex'): string | number[] {
+  encrypt(msg: number[] | string, enc?: 'hex'): string | number[] {
     const iv = Random(32)
     msg = toArray(msg, enc)
     const { result, authenticationTag } = AESGCM(
       msg,
       [],
       iv,
-      this.toArray()
+      this.toArray('be', 32)
     )
     return encode([...iv, ...result, ...authenticationTag], enc)
   }
@@ -54,7 +68,7 @@ export default class SymmetricKey extends BigNumber {
    *
    * @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[] {
+  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)

package/src/primitives/__tests/HMAC.test.ts

@@ -47,12 +47,12 @@ describe('HMAC', function () {
     function test (opt): void {
       it(`should not fail at ${opt.name as string}`, function (): void {
         let h = new SHA256HMAC(opt.key)
-        expect(h.update(opt.msg, opt.msgEnc).digest('hex')).toEqual(opt.res)
+        expect(h.update(opt.msg, opt.msgEnc).digestHex()).toEqual(opt.res)
         h = h = new SHA256HMAC(opt.key)
         expect(h
           .update(opt.msg.slice(0, 10), opt.msgEnc)
           .update(opt.msg.slice(10), opt.msgEnc)
-          .digest('hex')).toEqual(opt.res)
+          .digestHex()).toEqual(opt.res)
       })
     }
   })

package/src/primitives/__tests/Hash.test.ts

@@ -11,13 +11,13 @@ describe('Hash', function () {
       const res = cases[i][1]
       const enc = cases[i][2]
 
-      let dgst = new Hash().update(msg, enc).digest('hex')
+      let dgst = new Hash().update(msg, enc).digestHex()
       expect(dgst).toEqual(res)
 
       // Split message
       dgst = new Hash().update(msg.slice(0, 2), enc)
         .update(msg.slice(2), enc)
-        .digest('hex')
+        .digestHex()
       expect(dgst).toEqual(res)
     }
   }

package/src/primitives/index.ts

@@ -1,4 +1,5 @@
 export { default as BigNumber } from './BigNumber.js'
+export { default as Curve } from './Curve.js'
 export { default as Point } from './Point.js'
 export { default as PublicKey } from './PublicKey.js'
 export { default as Signature } from './Signature.js'

package/src/primitives/utils.ts

@@ -2,12 +2,12 @@ import BigNumber from './BigNumber.js'
 import { hash256 } from './Hash.js'
 
 /**
- * Appends a '0' to a single-character word to ensure it has two characters.
+ * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
  * @param {string} word - The input word.
- * @returns {string} - The word with a leading '0' if it's a single character; otherwise, the original word.
+ * @returns {string} - The word with a leading '0' if it's an odd character length; otherwise, the original word.
  */
 export const zero2 = (word: string): string => {
-  if (word.length === 1) {
+  if (word.length % 2 === 1) {
     return '0' + word
   } else {
     return word

package/src/script/__tests/Script.test.ts

@@ -1,4 +1,6 @@
 import Script from '../../../dist/cjs/src/script/Script'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import P2PKH from '../../../dist/cjs/src/script/templates/P2PKH'
 import OP from '../../../dist/cjs/src/script/OP'
 import { toHex } from '../../../dist/cjs/src/primitives/utils'
 import scriptFromVector from './scriptFromVector'
@@ -23,6 +25,38 @@ describe('Script', () => {
     })
   })
 
+  describe('fromAddress', () => {
+    it('should parse this mainnet Base58Check encoded address string and result in a P2PKH Script', () => {
+      const priv = PrivateKey.fromRandom()
+      const address = priv.toAddress()
+      const publicKey = priv.toPublicKey()
+      const pkh = publicKey.toHash()
+      const lockingScriptFromTemplate = new P2PKH().lock(pkh).toASM()
+      const script = new P2PKH().lock(address).toASM()
+      expect(script).toBe(lockingScriptFromTemplate)
+    })
+
+    it('should parse this testnet Base58Check encoded address string and result in a P2PKH Script', () => {
+      const priv = PrivateKey.fromRandom()
+      const address = priv.toAddress([0x6f])
+      const publicKey = priv.toPublicKey()
+      const pkh = publicKey.toHash()
+      const lockingScriptFromTemplate = new P2PKH().lock(pkh).toASM()
+      const script = new P2PKH().lock(address).toASM()
+      expect(script).toBe(lockingScriptFromTemplate)
+    })
+
+    it('should error when attempting to parse this strange Base58Check encoded string', () => {
+      const priv = PrivateKey.fromRandom()
+      const address = priv.toAddress([0x88])
+      function attemptToDeriveAddress() {
+        const script = new P2PKH().lock(address).toASM()
+        return script
+      }
+      expect(attemptToDeriveAddress).toThrow('only P2PKH is supported')
+    })
+  })
+
   describe('fromBinary', () => {
     it('should parse this buffer containing an OP code', () => {
       const buf = Buffer.alloc(1)