@bsv/sdk 1.10.4 → 2.0.0

package/src/identity/__tests/IdentityClient.test.ts

@@ -15,41 +15,14 @@ jest.mock('../../script', () => {
   }
 })
 
-// Store mock functions for LookupResolver so tests can configure them
-const mockLookupResolverQuery = jest.fn()
-
 jest.mock('../../overlay-tools/index.js', () => {
   return {
     TopicBroadcaster: jest.fn().mockImplementation(() => ({
       broadcast: jest.fn().mockResolvedValue('broadcastResult')
-    })),
-    LookupResolver: jest.fn().mockImplementation(() => ({
-      query: mockLookupResolverQuery
-    }))
-  }
-})
-
-// Mock VerifiableCertificate for resolveViaLookup tests
-const mockDecryptFields = jest.fn()
-const mockVerify = jest.fn()
-
-jest.mock('../../auth/certificates/VerifiableCertificate.js', () => {
-  return {
-    VerifiableCertificate: jest.fn().mockImplementation(() => ({
-      decryptFields: mockDecryptFields,
-      verify: mockVerify
     }))
   }
 })
 
-// Mock ProtoWallet for resolveViaLookup tests
-jest.mock('../../wallet/ProtoWallet.js', () => {
-  return {
-    __esModule: true,
-    default: jest.fn().mockImplementation(() => ({}))
-  }
-})
-
 jest.mock('../../transaction/index.js', () => {
   return {
     Transaction: {
@@ -294,187 +267,6 @@ describe('IdentityClient', () => {
       // Wallet method should not be called when contact is found
       expect(walletMock.discoverByIdentityKey).not.toHaveBeenCalled()
     })
-
-    it('should fallback to LookupResolver when no wallet is available', async () => {
-      // Mock wallet methods to throw "No wallet available" error
-      walletMock.discoverByIdentityKey = jest.fn().mockRejectedValue(
-        new Error('No wallet available over any communication substrate. Install a BSV wallet today!')
-      )
-
-      // Mock ContactsManager to also throw (since it requires wallet)
-      const mockContactsManager = identityClient['contactsManager']
-      mockContactsManager.getContacts = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      // Setup mock certificate data that would come from lookup
-      const certData = {
-        type: KNOWN_IDENTITY_TYPES.xCert,
-        serialNumber: 'serial123',
-        subject: 'test-identity-key',
-        certifier: '02cf6cdf466951d8dfc9e7c9367511d0007ed6fba35ed42d425cc412fd6cfd4a17',
-        revocationOutpoint: 'outpoint',
-        fields: { userName: 'encrypted', profilePhoto: 'encrypted' },
-        keyring: { fieldKey: 'keyringValue' },
-        signature: 'sig123'
-      }
-
-      // Mock LookupResolver to return output-list with certificate data
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'output-list',
-        outputs: [{
-          beef: new Uint8Array([1, 2, 3]),
-          outputIndex: 0
-        }]
-      })
-
-      // Mock PushDrop.decode to return certificate JSON
-      const { PushDrop } = require('../../script')
-      PushDrop.decode.mockReturnValue({
-        fields: [new TextEncoder().encode(JSON.stringify(certData))]
-      })
-
-      // Mock VerifiableCertificate methods
-      mockDecryptFields.mockResolvedValue({
-        userName: 'TestUser',
-        profilePhoto: 'test-photo-url'
-      })
-      mockVerify.mockResolvedValue(true)
-
-      const identities = await identityClient.resolveByIdentityKey(
-        { identityKey: 'test-identity-key' },
-        false // Don't override with contacts
-      )
-
-      // Verify wallet was called and threw
-      expect(walletMock.discoverByIdentityKey).toHaveBeenCalled()
-
-      // Verify LookupResolver was queried
-      expect(mockLookupResolverQuery).toHaveBeenCalledWith({
-        service: 'ls_identity',
-        query: {
-          certifiers: ['02cf6cdf466951d8dfc9e7c9367511d0007ed6fba35ed42d425cc412fd6cfd4a17'],
-          identityKey: 'test-identity-key'
-        }
-      })
-
-      // Verify results were returned from fallback
-      expect(identities).toHaveLength(1)
-      expect(identities[0].name).toBe('TestUser')
-      expect(identities[0].identityKey).toBe('test-identity-key')
-    })
-
-    it('should return empty array when LookupResolver returns no results', async () => {
-      walletMock.discoverByIdentityKey = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      const mockContactsManager = identityClient['contactsManager']
-      mockContactsManager.getContacts = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      // Mock LookupResolver to return empty results
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'output-list',
-        outputs: []
-      })
-
-      const identities = await identityClient.resolveByIdentityKey(
-        { identityKey: 'nonexistent-key' },
-        false
-      )
-
-      expect(identities).toHaveLength(0)
-    })
-
-    it('should return empty array when LookupResolver returns non-output-list type', async () => {
-      walletMock.discoverByIdentityKey = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      const mockContactsManager = identityClient['contactsManager']
-      mockContactsManager.getContacts = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      // Mock LookupResolver to return different type
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'freeform',
-        result: {}
-      })
-
-      const identities = await identityClient.resolveByIdentityKey(
-        { identityKey: 'some-key' },
-        false
-      )
-
-      expect(identities).toHaveLength(0)
-    })
-
-    it('should skip invalid certificates and continue processing', async () => {
-      walletMock.discoverByIdentityKey = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      const mockContactsManager = identityClient['contactsManager']
-      mockContactsManager.getContacts = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      // Mock LookupResolver to return multiple outputs
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'output-list',
-        outputs: [
-          { beef: new Uint8Array([1]), outputIndex: 0 },
-          { beef: new Uint8Array([2]), outputIndex: 0 }
-        ]
-      })
-
-      // First call throws (invalid cert), second succeeds
-      const { PushDrop } = require('../../script')
-      PushDrop.decode
-        .mockImplementationOnce(() => { throw new Error('Invalid script') })
-        .mockImplementationOnce(() => ({
-          fields: [new TextEncoder().encode(JSON.stringify({
-            type: KNOWN_IDENTITY_TYPES.xCert,
-            serialNumber: 'serial',
-            subject: 'valid-key',
-            certifier: 'certifier',
-            revocationOutpoint: 'outpoint',
-            fields: {},
-            keyring: {},
-            signature: 'sig'
-          }))]
-        }))
-
-      mockDecryptFields.mockResolvedValue({ userName: 'ValidUser' })
-      mockVerify.mockResolvedValue(true)
-
-      const identities = await identityClient.resolveByIdentityKey(
-        { identityKey: 'some-key' },
-        false
-      )
-
-      // Should have 1 identity (the valid one)
-      expect(identities).toHaveLength(1)
-      expect(identities[0].name).toBe('ValidUser')
-    })
-
-    it('should re-throw non-wallet errors', async () => {
-      walletMock.discoverByIdentityKey = jest.fn().mockRejectedValue(
-        new Error('Network timeout')
-      )
-
-      const mockContactsManager = identityClient['contactsManager']
-      mockContactsManager.getContacts = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      await expect(
-        identityClient.resolveByIdentityKey({ identityKey: 'test-key' }, false)
-      ).rejects.toThrow('Network timeout')
-    })
   })
 
   it('should throw if createAction returns no tx', async () => {
@@ -575,11 +367,7 @@ describe('IdentityClient', () => {
         {
           name: 'Alice Smith',
           identityKey: 'alice-key',
-          avatarURL: '',
-          abbreviatedKey: 'alice-i...',
-          badgeIconURL: '',
-          badgeLabel: '',
-          badgeClickURL: ''
+          avatarURL: '', abbreviatedKey: 'alice-i...', badgeIconURL: '', badgeLabel: '', badgeClickURL: ''
         }
       ]
 
@@ -628,82 +416,6 @@ describe('IdentityClient', () => {
       expect(identities[0].name).toBe('alice@example.com') // Should be discovered identity, not contact
       expect(mockContactsManager.getContacts).not.toHaveBeenCalled() // Should not fetch contacts
     })
-
-    it('should fallback to LookupResolver when no wallet is available for attribute search', async () => {
-      walletMock.discoverByAttributes = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      // Setup mock certificate data
-      const certData = {
-        type: KNOWN_IDENTITY_TYPES.emailCert,
-        serialNumber: 'serial123',
-        subject: 'found-identity-key',
-        certifier: '02cf6cdf466951d8dfc9e7c9367511d0007ed6fba35ed42d425cc412fd6cfd4a17',
-        revocationOutpoint: 'outpoint',
-        fields: { email: 'encrypted' },
-        keyring: { fieldKey: 'keyringValue' },
-        signature: 'sig123'
-      }
-
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'output-list',
-        outputs: [{
-          beef: new Uint8Array([1, 2, 3]),
-          outputIndex: 0
-        }]
-      })
-
-      const { PushDrop } = require('../../script')
-      PushDrop.decode.mockReturnValue({
-        fields: [new TextEncoder().encode(JSON.stringify(certData))]
-      })
-
-      mockDecryptFields.mockResolvedValue({ email: 'found@example.com' })
-      mockVerify.mockResolvedValue(true)
-
-      const identities = await identityClient.resolveByAttributes(
-        { attributes: { email: 'found@example.com' } },
-        false
-      )
-
-      // Verify LookupResolver was queried with attributes
-      expect(mockLookupResolverQuery).toHaveBeenCalledWith({
-        service: 'ls_identity',
-        query: {
-          certifiers: ['02cf6cdf466951d8dfc9e7c9367511d0007ed6fba35ed42d425cc412fd6cfd4a17'],
-          attributes: { any: 'found@example.com' }
-        }
-      })
-
-      expect(identities).toHaveLength(1)
-      expect(identities[0].name).toBe('found@example.com')
-    })
-
-    it('should use multi-attribute query when multiple attributes provided', async () => {
-      walletMock.discoverByAttributes = jest.fn().mockRejectedValue(
-        new Error('No wallet available')
-      )
-
-      mockLookupResolverQuery.mockResolvedValue({
-        type: 'output-list',
-        outputs: []
-      })
-
-      await identityClient.resolveByAttributes(
-        { attributes: { firstName: 'John', lastName: 'Doe' } },
-        false
-      )
-
-      // Verify query uses full attributes object when more than one
-      expect(mockLookupResolverQuery).toHaveBeenCalledWith({
-        service: 'ls_identity',
-        query: {
-          certifiers: ['02cf6cdf466951d8dfc9e7c9367511d0007ed6fba35ed42d425cc412fd6cfd4a17'],
-          attributes: { firstName: 'John', lastName: 'Doe' }
-        }
-      })
-    })
   })
 
   describe('parseIdentity', () => {

package/src/overlay-tools/__tests/SHIPBroadcaster.test.ts

@@ -14,9 +14,16 @@ const mockResolver = {
 }
 
 describe('SHIPCast', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
   beforeEach(() => {
     mockFacilitator.send.mockReset()
     mockResolver.query.mockReset()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
   })
 
   it('Handles constructor errors', () => {
@@ -339,12 +346,8 @@ describe('SHIPCast', () => {
     })
     const testTx = new Transaction(1, [], [], 0)
 
-    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
-
     const result = await b.broadcast(testTx)
 
-    expect(consoleErrorSpy).toHaveBeenCalled()
-
     expect(result).toEqual({
       status: 'error',
       code: 'ERR_ALL_HOSTS_REJECTED',
@@ -1080,13 +1083,8 @@ describe('SHIPCast', () => {
       resolver: mockResolver as unknown as LookupResolver
     })
     const testTx = new Transaction(1, [], [], 0)
-
-    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
-
     const response = await b.broadcast(testTx)
 
-    expect(consoleErrorSpy).toHaveBeenCalled()
-
     // Since the host responded (successfully in terms of HTTP), but with invalid data, we should consider it a failure
     expect(response).toEqual({
       status: 'error',

package/src/primitives/TransactionSignature.ts

@@ -3,6 +3,7 @@ import BigNumber from './BigNumber.js'
 import * as Hash from './Hash.js'
 import { toArray, Writer } from './utils.js'
 import Script from '../script/Script.js'
+import OP from '../script/OP.js'
 import TransactionInput from '../transaction/TransactionInput.js'
 import TransactionOutput from '../transaction/TransactionOutput.js'
 
@@ -26,6 +27,10 @@ interface TransactionSignatureFormatParams {
   lockTime: number
   scope: number
   cache?: SignatureHashCache
+  /**
+   * Supports running bitcoin-abc test vectors which reuses the CHRONICLE bit.
+   */
+  ignoreChronicle?: boolean
 }
 
 const EMPTY_SCRIPT = new Uint8Array(0)
@@ -34,18 +39,99 @@ 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_CHRONICLE = 0x00000020
   public static readonly SIGHASH_FORKID = 0x00000040
   public static readonly SIGHASH_ANYONECANPAY = 0x00000080
 
   scope: number
 
   /**
-   * Formats the SIGHASH preimage for the targeted input, optionally using a cache to skip recomputing shared hash prefixes.
-   * @param params - Context for the signing input plus transaction metadata.
-   * @param params.cache - Optional cache storing previously computed `hashPrevouts`, `hashSequence`, or `hashOutputs*` values; it will be populated if present.
+   * Implements the original bitcoin transaction signature digest preimage algorithm (OTDA).
+   * @param params
+   * @returns preimage as a byte array
    */
-  static format (params: TransactionSignatureFormatParams): number[] {
-    return Array.from(this.formatBytes(params))
+  static formatOTDA (params: TransactionSignatureFormatParams): Uint8Array {
+    const isAnyoneCanPay = (params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === TransactionSignature.SIGHASH_ANYONECANPAY
+    const isSingle = (params.scope & 31) === TransactionSignature.SIGHASH_SINGLE
+    const isNone = (params.scope & 31) === TransactionSignature.SIGHASH_NONE
+    const isAll = (params.scope & 31) === TransactionSignature.SIGHASH_ALL || (!isSingle && !isNone)
+
+    const subscript = new Script([...params.subscript.chunks])
+    subscript.findAndDelete(new Script().writeOpCode(OP.OP_CODESEPARATOR))
+
+    const currentInput = {
+      sourceTXID: params.sourceTXID,
+      sourceOutputIndex: params.sourceOutputIndex,
+      sequence: params.inputSequence,
+      script: subscript.toBinary()
+    }
+
+    const writer = new Writer()
+
+    function writeInputs (inputs: Array<{ sourceTXID: string, sourceOutputIndex: number, sequence: number, script: number[] }>): void {
+      writer.writeVarIntNum(inputs.length)
+      for (const input of inputs) {
+        writer.writeReverse(toArray(input.sourceTXID, 'hex'))
+        writer.writeUInt32LE(input.sourceOutputIndex)
+        writer.writeVarIntNum(input.script.length)
+        writer.write(input.script)
+        writer.writeUInt32LE(input.sequence)
+      }
+    }
+
+    function writeOutputs (outputs: Array<{ satoshis: number, script: number[] }>): void {
+      writer.writeVarIntNum(outputs.length)
+      for (const output of outputs) {
+        writer.writeUInt64LE(output.satoshis)
+        writer.writeVarIntNum(output.script.length)
+        writer.write(output.script)
+      }
+    }
+
+    // Version
+    writer.writeInt32LE(params.transactionVersion)
+
+    const emptyScript = new Script().toBinary()
+
+    if (!isAnyoneCanPay) {
+      const inputs = params.otherInputs.map(input => ({
+        sourceTXID: input.sourceTXID ?? input.sourceTransaction?.id('hex') ?? '',
+        sourceOutputIndex: input.sourceOutputIndex,
+        sequence: (isSingle || isNone) ? 0 : (input.sequence ?? 0xffffffff), // Default to max sequence number
+        script: emptyScript
+      }))
+      inputs.splice(params.inputIndex, 0, currentInput)
+      writeInputs(inputs)
+    } else if (isAnyoneCanPay) {
+      writeInputs([currentInput])
+    }
+
+    if (isAll) {
+      const outputs = params.outputs.map(output => ({
+        satoshis: output.satoshis ?? 0, // Default to 0 if undefined
+        script: output.lockingScript.toBinary()
+      }))
+      writeOutputs(outputs)
+    } else if (isSingle) {
+      const outputs: Array<{ satoshis: number, script: number[] }> = []
+      for (let i = 0; i < params.inputIndex; i++) outputs.push({ satoshis: -1, script: emptyScript })
+      const o = params.outputs[params.inputIndex]
+      if (o !== undefined) { outputs.push({ satoshis: o.satoshis ?? 0, script: o.lockingScript.toBinary() }) }
+      writeOutputs(outputs)
+    } else if (isNone) {
+      writeOutputs([])
+    }
+
+    // Locktime
+    writer.writeUInt32LE(params.lockTime)
+
+    // sighashType
+    writer.writeUInt32LE(params.scope >>> 0)
+
+    const buf = writer.toUint8Array()
+    // const preimage = toHex(buf)
+    // const sighash = toHex(Hash.hash256(buf))
+    return buf
   }
 
   /**
@@ -54,7 +140,7 @@ export default class TransactionSignature extends Signature {
    * @param params.cache - Optional `SignatureHashCache` that may already contain hashed prefixes and is populated during formatting.
    * @returns Bytes for signing.
    */
-  static formatBytes (params: TransactionSignatureFormatParams): Uint8Array {
+  static formatBip143 (params: TransactionSignatureFormatParams): Uint8Array {
     const cache = params.cache
     const currentInput = {
       sourceTXID: params.sourceTXID,
@@ -79,7 +165,9 @@ export default class TransactionSignature extends Signature {
         writer.writeUInt32LE(input.sourceOutputIndex)
       }
 
-      return Hash.hash256(writer.toUint8Array())
+      const buf = writer.toUint8Array()
+      const ret = Hash.hash256(buf)
+      return ret
     }
 
     const getSequenceHash = (): number[] => {
@@ -90,7 +178,9 @@ export default class TransactionSignature extends Signature {
         writer.writeUInt32LE(sequence)
       }
 
-      return Hash.hash256(writer.toUint8Array())
+      const buf = writer.toUint8Array()
+      const ret = Hash.hash256(buf)
+      return ret
     }
 
     function getOutputsHash (outputIndex?: number): number[] {
@@ -120,7 +210,9 @@ export default class TransactionSignature extends Signature {
         writer.write(script)
       }
 
-      return Hash.hash256(writer.toUint8Array())
+      const buf = writer.toUint8Array()
+      const ret = Hash.hash256(buf)
+      return ret
     }
 
     let hashPrevouts = new Array(32).fill(0)
@@ -210,7 +302,34 @@ export default class TransactionSignature extends Signature {
     // sighashType
     writer.writeUInt32LE(params.scope >>> 0)
 
-    return writer.toUint8Array()
+    const buf = writer.toUint8Array()
+    // const preimage = toHex(buf)
+    // const sighash = toHex(Hash.hash256(buf))
+    return buf
+  }
+
+  /**
+   * Formats the SIGHASH preimage for the targeted input, optionally using a cache to skip recomputing shared hash prefixes.
+   * @param params - Context for the signing input plus transaction metadata.
+   * @param params.cache - Optional cache storing previously computed `hashPrevouts`, `hashSequence`, or `hashOutputs*` values; it will be populated if present.
+   */
+  static format (params: TransactionSignatureFormatParams): number[] {
+    return Array.from(this.formatBytes(params))
+  }
+
+  static formatBytes (params: TransactionSignatureFormatParams): Uint8Array {
+    const hasForkId = (params.scope & TransactionSignature.SIGHASH_FORKID) !== 0
+    const hasChronicle = params.ignoreChronicle !== true && (params.scope & TransactionSignature.SIGHASH_CHRONICLE) !== 0
+
+    if (hasForkId && !hasChronicle) {
+      return TransactionSignature.formatBip143(params)
+    }
+
+    if (!hasForkId || (hasForkId && hasChronicle)) {
+      return TransactionSignature.formatOTDA(params)
+    }
+
+    return new Uint8Array(0)
   }
 
   // The format used in a tx

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

@@ -323,13 +323,17 @@ describe('verifyNotNull', () => {
   })
 })
 
-describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
+describe('toUTF8 UTF-8 decoding', () => {
 
-  it('replaces invalid 2-byte sequences with U+FFFD', () => {
+  it('decodes ASCII bytes', () => {
+    expect(toUTF8([0x48, 0x65, 0x6c, 0x6c, 0x6f])).toBe('Hello')
+  })
+
+  it('replaces invalid 2-byte sequences with U+FFFD and continues decoding', () => {
     // 0xC2 should expect a continuation byte 0x80–0xBF
     const arr = [0xC2, 0x20]   // 0x20 is INVALID continuation
     const str = toUTF8(arr)
-    expect(str).toBe('\uFFFD')
+    expect(str).toBe('\uFFFD ')
   })
 
   it('decodes valid 3-byte sequences', () => {
@@ -337,10 +341,10 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(euro)).toBe('€')
   })
 
-  it('replaces invalid 3-byte sequences', () => {
+  it('replaces invalid 3-byte sequences with U+FFFD and continues decoding', () => {
     // Middle byte invalid
     const arr = [0xE2, 0x20, 0xAC]
-    expect(toUTF8(arr)).toBe('\uFFFD')
+    expect(toUTF8(arr)).toBe('\uFFFD \uFFFD')
   })
 
   it('decodes valid 4-byte sequences into surrogate pairs', () => {
@@ -348,10 +352,10 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(smile)).toBe('😀')
   })
 
-  it('replaces invalid 4-byte sequences with U+FFFD', () => {
+  it('replaces invalid 4-byte sequences with U+FFFD and continues decoding', () => {
     // 0x9F is valid, 0x20 is INVALID continuation for byte 3
     const arr = [0xF0, 0x9F, 0x20, 0x80]
-    expect(toUTF8(arr)).toBe('\uFFFD')
+    expect(toUTF8(arr)).toBe('\uFFFD \uFFFD')
   })
 
   it('replaces incomplete UTF-8 sequence at end', () => {
@@ -359,6 +363,25 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(arr)).toBe('\uFFFD')
   })
 
+  it('replaces overlong sequences with U+FFFD', () => {
+    expect(toUTF8([0xC0, 0xAF])).toBe('\uFFFD\uFFFD')
+  })
+
+  it('replaces UTF-8 encoded surrogates with U+FFFD', () => {
+    expect(toUTF8([0xED, 0xA0, 0x80])).toBe('\uFFFD\uFFFD\uFFFD')
+  })
+
+})
+
+describe("toArray('utf8') UTF-8 encoding", () => {
+  it('round-trips UTF-8 strings', () => {
+    const s = 'Hello € 😀'
+    expect(toUTF8(toArray(s, 'utf8') as number[])).toBe(s)
+  })
+
+  it('replaces lone surrogates with U+FFFD when encoding', () => {
+    expect(toArray('\uD800', 'utf8')).toEqual([0xEF, 0xBF, 0xBD])
+  })
 })
 
 describe('Point.encode infinity handling', () => {