@bsv/sdk 1.3.24 → 1.3.26

package/package.json

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

package/src/auth/clients/AuthFetch.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { Utils, Random, P2PKH, PublicKey, WalletInterface } from '../../../mod.js'
+import { Utils, Random, P2PKH, PublicKey, WalletInterface, createNonce } from '../../../mod.js'
 import { Peer } from '../Peer.js'
 import { SimplifiedFetchTransport } from '../transports/SimplifiedFetchTransport.js'
 import { SessionManager } from '../SessionManager.js'
@@ -397,15 +397,15 @@ export class AuthFetch {
     }
 
     // Create a random suffix for the derivation path
-    const derivationSuffix = Utils.toBase64(Random(10))
+    const derivationSuffix = await createNonce(this.wallet)
 
     // Derive the script hex from the server identity key
     const { publicKey: derivedPublicKey } = await this.wallet.getPublicKey({
-      protocolID: [2, 'wallet payment'],
+      protocolID: [2, '3241645161d8'], // wallet payment protocol
       keyID: `${derivationPrefix} ${derivationSuffix}`,
       counterparty: serverIdentityKey
     })
-    const lockingScript = new P2PKH().lock(PublicKey.fromString(derivedPublicKey).toHash()).toHex()
+    const lockingScript = new P2PKH().lock(PublicKey.fromString(derivedPublicKey).toAddress()).toHex()
 
     // Create the payment transaction using createAction
     const { tx } = await this.wallet.createAction({
@@ -421,6 +421,7 @@ export class AuthFetch {
     config.headers = config.headers || {}
     config.headers['x-bsv-payment'] = JSON.stringify({
       derivationPrefix,
+      derivationSuffix,
       transaction: Utils.toBase64(tx)
     })
     config.retryCounter ??= 3

package/src/auth/utils/createNonce.ts

@@ -2,7 +2,8 @@ import {
   Utils,
   Random,
   WalletInterface,
-  WalletCounterparty
+  WalletCounterparty,
+  Base64String
 } from '../../../mod.js'
 
 /**
@@ -14,7 +15,7 @@ import {
 export async function createNonce(
   wallet: WalletInterface,
   counterparty: WalletCounterparty = 'self'
-): Promise<string> {
+): Promise<Base64String> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
   // Create an sha256 HMAC

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,4 @@
-import { Utils, WalletInterface, WalletCounterparty } from '../../../mod.js'
+import { Utils, WalletInterface, WalletCounterparty, Base64String } from '../../../mod.js'
 
 /**
  * Verifies a nonce derived from a wallet
@@ -8,7 +8,7 @@ import { Utils, WalletInterface, WalletCounterparty } from '../../../mod.js'
  * @returns The status of the validation
  */
 export async function verifyNonce(
-  nonce: string,
+  nonce: Base64String,
   wallet: WalletInterface,
   counterparty: WalletCounterparty = 'self'
 ): Promise<boolean> {

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

@@ -15,7 +15,8 @@ describe('utils', () => {
     expect(toArray('1234', 'hex')).toEqual([0x12, 0x34])
     expect(toArray('1234')).toEqual([49, 50, 51, 52])
     expect(toArray('1234', 'utf8')).toEqual([49, 50, 51, 52])
-    expect(toArray('\u1234234')).toEqual([18, 52, 50, 51, 52])
+    expect(toArray('\u1234', 'utf8')).toEqual([225, 136, 180])
+    expect(toArray('\u1234' + '234', 'utf8')).toEqual([225, 136, 180, 50, 51, 52])
     expect(toArray([1, 2, 3, 4])).toEqual([1, 2, 3, 4])
   })
 
@@ -156,4 +157,53 @@ describe('utils', () => {
       })
     })
   })
+
+  test('should return an empty array for an empty string', () => {
+    expect(toArray("")).toEqual([])
+  })
+
+  test('should encode ASCII characters correctly', () => {
+    const input = "Hello, World!"
+    const expected = [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
+    expect(toArray(input)).toEqual(expected)
+  })
+
+  test('should encode 2-byte characters correctly', () => {
+    // "é" (U+00E9) should encode to [0xC3, 0xA9]
+    expect(toArray("é")).toEqual([0xC3, 0xA9])
+  })
+
+  test('should encode 3-byte characters correctly', () => {
+    // "€" (U+20AC) should encode to [0xE2, 0x82, 0xAC]
+    expect(toArray("€")).toEqual([0xE2, 0x82, 0xAC])
+  })
+
+  test('should encode 4-byte characters correctly', () => {
+    // "😃" (U+1F603) should encode to [0xF0, 0x9F, 0x98, 0x83]
+    expect(toArray("😃")).toEqual([0xF0, 0x9F, 0x98, 0x83])
+  })
+
+  test('should encode mixed content correctly', () => {
+    // "Hello, 😃! €" contains ASCII, an emoji, and a 3-byte character.
+    const input = "Hello, 😃! €"
+    const expected = [
+      // "Hello, " => ASCII bytes:
+      72, 101, 108, 108, 111, 44, 32,
+      // "😃" => 4-byte sequence:
+      0xF0, 0x9F, 0x98, 0x83,
+      // "!" => ASCII, then space:
+      33, 32,
+      // "€" => 3-byte sequence:
+      0xE2, 0x82, 0xAC
+    ]
+    expect(toArray(input)).toEqual(expected)
+  })
+
+  test('should replace lone surrogates with the replacement character', () => {
+    // An unpaired high surrogate "\uD800" should be replaced with U+FFFD,
+    // which is encoded in UTF-8 as [0xEF, 0xBF, 0xBD]
+    const input = "\uD800"
+    const expected = [0xEF, 0xBF, 0xBD]
+    expect(toArray(input)).toEqual(expected)
+  })
 })

package/src/primitives/utils.ts

@@ -84,19 +84,61 @@ const base64ToArray = (msg: string): number[] => {
   return result
 }
 
-const utf8ToArray = (msg: string): number[] => {
-  const res: number[] = []
-  for (let i = 0; i < msg.length; i++) {
-    const c = msg.charCodeAt(i)
-    const hi = c >> 8
-    const lo = c & 0xff
-    if (hi !== 0) {
-      res.push(hi, lo)
+/**
+ * Encodes a string into an array of bytes representing its UTF-8 encoding.
+ * Any lone surrogates are replaced with the Unicode replacement character (U+FFFD).
+ *
+ * @param str - The string to encode.
+ * @returns An array of numbers, each representing a byte in the UTF-8 encoded string.
+ */
+function utf8ToArray (str: string): number[] {
+  const result: number[] = []
+
+  for (let i = 0; i < str.length; i++) {
+    const cp = str.codePointAt(i)
+    if (cp === undefined) {
+      // Should never be out of range.
+      throw new Error(`Index out of range: ${i}`)
+    }
+    let codePoint = cp
+
+    if (codePoint > 0xFFFF) {
+      // Valid surrogate pair => skip the next code unit because codePointAt
+      // has already combined them into a single code point.
+      i++
+    } else {
+      // Check if codePoint is a lone (unpaired) high surrogate or low surrogate.
+      if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+        // Replace with the replacement character (U+FFFD).
+        codePoint = 0xFFFD
+      }
+    }
+
+    // Encode according to the UTF-8 standard
+    if (codePoint <= 0x7F) {
+      result.push(codePoint)
+    } else if (codePoint <= 0x7FF) {
+      result.push(
+        0xC0 | (codePoint >> 6),
+        0x80 | (codePoint & 0x3F)
+      )
+    } else if (codePoint <= 0xFFFF) {
+      result.push(
+        0xE0 | (codePoint >> 12),
+        0x80 | ((codePoint >> 6) & 0x3F),
+        0x80 | (codePoint & 0x3F)
+      )
     } else {
-      res.push(lo)
+      result.push(
+        0xF0 | (codePoint >> 18),
+        0x80 | ((codePoint >> 12) & 0x3F),
+        0x80 | ((codePoint >> 6) & 0x3F),
+        0x80 | (codePoint & 0x3F)
+      )
     }
   }
-  return res
+
+  return result
 }
 
 /**