@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/auth/transports/SimplifiedFetchTransport.ts

@@ -0,0 +1,446 @@
+// @ts-nocheck
+// @ts-expect-error
+import { AuthMessage, RequestedCertificateSet, Transport } from '../types.js'
+import * as Utils from '../../primitives/utils.js'
+
+const defaultFetch: typeof fetch = 
+  typeof globalThis !== 'undefined' && typeof globalThis.fetch === 'function'
+    ? globalThis.fetch.bind(globalThis)
+    : fetch
+
+/**
+ * Implements an HTTP-specific transport for handling Peer mutual authentication messages.
+ * This class integrates with fetch to send and receive authenticated messages between peers.
+ */
+export class SimplifiedFetchTransport implements Transport {
+  private onDataCallback?: (message: AuthMessage) => void
+  fetchClient: typeof fetch
+  baseUrl: string
+
+  /**
+   * Constructs a new instance of SimplifiedFetchTransport.
+   * @param baseUrl - The base URL for all HTTP requests made by this transport.
+   * @param fetchClient - A fetch implementation to use for HTTP requests (default: global fetch).
+   */
+  constructor (baseUrl: string, fetchClient = defaultFetch) {
+    if (typeof fetchClient !== 'function') {
+      throw new Error(
+        'SimplifiedFetchTransport requires a fetch implementation. ' +
+        'In environments without fetch, provide a polyfill or custom implementation.'
+      )
+    }
+    this.fetchClient = fetchClient
+    this.baseUrl = baseUrl
+  }
+
+  /**
+   * Sends a message to an HTTP server using the transport mechanism.
+   * Handles both general and authenticated message types. For general messages,
+   * the payload is deserialized and sent as an HTTP request. For other message types,
+   * the message is sent as a POST request to the `/auth` endpoint.
+   *
+   * @param message - The AuthMessage to send.
+   * @returns A promise that resolves when the message is successfully sent.
+   *
+   * @throws Will throw an error if no listener has been registered via `onData`.
+   */
+  async send (message: AuthMessage): Promise<void> {
+    if (this.onDataCallback == null) {
+      throw new Error('Listen before you start speaking. God gave you two ears and one mouth for a reason.')
+    }
+    if (message.messageType !== 'general') {
+      return await new Promise((resolve, reject) => {
+        void (async () => {
+          try {
+            const authUrl = `${this.baseUrl}/.well-known/auth`
+            const responsePromise = (async () => {
+              try {
+                return await this.fetchClient(authUrl, {
+                  method: 'POST',
+                  headers: {
+                    'Content-Type': 'application/json'
+                  },
+                  body: JSON.stringify(message)
+                })
+              } catch (error) {
+                throw this.createNetworkError(authUrl, error)
+              }
+            })()
+
+            // For initialRequest message, mark connection as established and start pool.
+            if (message.messageType !== 'initialRequest') {
+              resolve()
+            }
+
+            const response = await responsePromise
+            if (!response.ok) {
+              const responseBodyArray = Array.from(new Uint8Array(await response.arrayBuffer()))
+              throw this.createUnauthenticatedResponseError(authUrl, response, responseBodyArray)
+            }
+
+            if (this.onDataCallback != null) {
+              const responseMessage = await response.json()
+              this.onDataCallback(responseMessage as AuthMessage)
+            }
+
+            if (message.messageType === 'initialRequest') {
+              resolve()
+            }
+          } catch (e) {
+            reject(e)
+          }
+        })()
+      })
+    } else {
+      // Parse message payload
+      const httpRequest = this.deserializeRequestPayload(message.payload)
+
+      // Send the byte array as the HTTP payload
+      const url = `${this.baseUrl}${httpRequest.urlPostfix}`
+      const httpRequestWithAuthHeaders: any = httpRequest
+      if (typeof httpRequest.headers !== 'object') {
+        httpRequestWithAuthHeaders.headers = {}
+      }
+
+      // Append auth headers in request to server
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-version'] = message.version
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-identity-key'] = message.identityKey
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-nonce'] = message.nonce
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-your-nonce'] = message.yourNonce
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-signature'] = Utils.toHex(message.signature)
+      httpRequestWithAuthHeaders.headers['x-bsv-auth-request-id'] = httpRequest.requestId
+
+      // Ensure Content-Type is set for requests with a body
+      if (httpRequestWithAuthHeaders.body != null) {
+        const headers = httpRequestWithAuthHeaders.headers
+        if (headers['content-type'] == null) {
+          throw new Error('Content-Type header is required for requests with a body.')
+        }
+
+        const contentType = String(headers['content-type'] ?? '')
+
+        // Transform body based on Content-Type
+        if (contentType.includes('application/json')) {
+          // Convert byte array to JSON string
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body)
+        } else if (contentType.includes('application/x-www-form-urlencoded')) {
+          // Convert byte array to URL-encoded string
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body)
+        } else if (contentType.includes('text/plain')) {
+          // Convert byte array to plain UTF-8 string
+          httpRequestWithAuthHeaders.body = Utils.toUTF8(httpRequestWithAuthHeaders.body)
+        } else {
+          // For all other content types, treat as binary data
+          httpRequestWithAuthHeaders.body = new Uint8Array(httpRequestWithAuthHeaders.body)
+        }
+      }
+
+      // Send the actual fetch request to the server
+      let response: Response
+      try {
+        response = await this.fetchClient(url, {
+          method: httpRequestWithAuthHeaders.method,
+          headers: httpRequestWithAuthHeaders.headers,
+          body: httpRequestWithAuthHeaders.body
+        })
+      } catch (error) {
+        throw this.createNetworkError(url, error)
+      }
+
+      const responseBodyBuffer = await response.arrayBuffer()
+      const responseBodyArray = Array.from(new Uint8Array(responseBodyBuffer))
+
+      const missingAuthHeaders = ['x-bsv-auth-version', 'x-bsv-auth-identity-key', 'x-bsv-auth-signature']
+        .filter(headerName => {
+          const headerValue = response.headers.get(headerName)
+          return headerValue == null || headerValue.trim().length === 0
+        })
+
+      if (missingAuthHeaders.length > 0) {
+        throw this.createUnauthenticatedResponseError(url, response, responseBodyArray, missingAuthHeaders)
+      }
+
+      const requestedCertificatesHeader = response.headers.get('x-bsv-auth-requested-certificates')
+      let requestedCertificates: RequestedCertificateSet | undefined
+      if (requestedCertificatesHeader != null) {
+        try {
+          requestedCertificates = JSON.parse(requestedCertificatesHeader) as RequestedCertificateSet
+        } catch (error) {
+          throw this.createMalformedHeaderError(url, 'x-bsv-auth-requested-certificates', requestedCertificatesHeader, error)
+        }
+      }
+      const payloadWriter = new Utils.Writer()
+      if (response.headers.get('x-bsv-auth-request-id') != null) {
+        payloadWriter.write(Utils.toArray(response.headers.get('x-bsv-auth-request-id'), 'base64'))
+      }
+      payloadWriter.writeVarIntNum(response.status)
+
+      // PARSE RESPONSE HEADERS FROM SERVER --------------------------------
+      // Parse response headers from the server and include only the signed headers:
+      // - Include custom headers prefixed with x-bsv (excluding those starting with x-bsv-auth)
+      // - Include the authorization header
+      const includedHeaders: Array<[string, string]> = []
+      response.headers.forEach((value, key) => {
+        const lowerKey = key.toLowerCase()
+        if ((lowerKey.startsWith('x-bsv-') || lowerKey === 'authorization') && !lowerKey.startsWith('x-bsv-auth')) {
+          includedHeaders.push([lowerKey, value])
+        }
+      })
+
+      // Sort the headers by key to ensure a consistent order for signing and verification.
+      includedHeaders.sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+
+      // nHeaders
+      payloadWriter.writeVarIntNum(includedHeaders.length)
+      for (let i = 0; i < includedHeaders.length; i++) {
+        // headerKeyLength
+        const headerKeyAsArray = Utils.toArray(includedHeaders[i][0], 'utf8')
+        payloadWriter.writeVarIntNum(headerKeyAsArray.length)
+        // headerKey
+        payloadWriter.write(headerKeyAsArray)
+        // headerValueLength
+        const headerValueAsArray = Utils.toArray(includedHeaders[i][1], 'utf8')
+        payloadWriter.writeVarIntNum(headerValueAsArray.length)
+        // headerValue
+        payloadWriter.write(headerValueAsArray)
+      }
+
+      // Handle body
+      payloadWriter.writeVarIntNum(responseBodyArray.length)
+      if (responseBodyArray.length > 0) {
+        payloadWriter.write(responseBodyArray)
+      }
+
+      // Build the correct AuthMessage for the response
+      const responseMessage: AuthMessage = {
+        version: response.headers.get('x-bsv-auth-version'),
+        messageType: response.headers.get('x-bsv-auth-message-type') === 'certificateRequest' ? 'certificateRequest' : 'general',
+        identityKey: response.headers.get('x-bsv-auth-identity-key'),
+        nonce: response.headers.get('x-bsv-auth-nonce') ?? undefined,
+        yourNonce: response.headers.get('x-bsv-auth-your-nonce') ?? undefined,
+        requestedCertificates,
+        payload: payloadWriter.toArray(),
+        signature: Utils.toArray(response.headers.get('x-bsv-auth-signature'), 'hex')
+      }
+
+      // If the server didn't provide the correct authentication headers, throw an error
+      if (responseMessage.version == null) {
+        throw this.createUnauthenticatedResponseError(url, response, responseBodyArray)
+      }
+
+      // Handle the response if data is received and callback is set
+      this.onDataCallback(responseMessage)
+    }
+  }
+
+  /**
+   * Registers a callback to handle incoming messages.
+   * This must be called before sending any messages to ensure responses can be processed.
+   *
+   * @param callback - A function to invoke when an incoming AuthMessage is received.
+   * @returns A promise that resolves once the callback is set.
+   */
+  async onData (callback: (message: AuthMessage) => Promise<void>): Promise<void> {
+    this.onDataCallback = (m) => {
+      void callback(m)
+    }
+  }
+
+  private createNetworkError (url: string, originalError: unknown): Error {
+    const baseMessage = `Network error while sending authenticated request to ${url}`
+    if (originalError instanceof Error) {
+      const error = new Error(`${baseMessage}: ${originalError.message}`)
+      error.stack = originalError.stack
+      ;(error as any).cause = originalError
+      return error
+    }
+    return new Error(`${baseMessage}: ${String(originalError)}`)
+  }
+
+  private createUnauthenticatedResponseError (
+    url: string,
+    response: Response,
+    bodyBytes: number[],
+    missingHeaders: string[] = []
+  ): Error {
+    const statusText = (response.statusText ?? '').trim()
+    const statusDescription = statusText.length > 0
+      ? `${response.status} ${statusText}`
+      : `${response.status}`
+    const headerMessage = missingHeaders.length > 0
+      ? `missing headers: ${missingHeaders.join(', ')}`
+      : 'response lacked required BSV auth headers'
+    const bodyPreview = this.getBodyPreview(bodyBytes, response.headers.get('content-type'))
+    const parts = [`Received HTTP ${statusDescription} from ${url} without valid BSV authentication (${headerMessage})`]
+    if (bodyPreview != null) {
+      parts.push(`body preview: ${bodyPreview}`)
+    }
+
+    const error = new Error(parts.join(' - '))
+    ;(error as any).details = {
+      url,
+      status: response.status,
+      statusText: response.statusText,
+      missingHeaders,
+      bodyPreview
+    }
+    return error
+  }
+
+  private createMalformedHeaderError (
+    url: string,
+    headerName: string,
+    headerValue: string,
+    cause: unknown
+  ): Error {
+    const errorMessage = `Failed to parse ${headerName} returned by ${url}: ${headerValue}`
+    if (cause instanceof Error) {
+      const error = new Error(`${errorMessage}. ${cause.message}`)
+      error.stack = cause.stack
+      ;(error as any).cause = cause
+      return error
+    }
+    return new Error(`${errorMessage}. ${String(cause)}`)
+  }
+
+  private getBodyPreview (bodyBytes: number[], contentType: string | null): string | undefined {
+    if (bodyBytes.length === 0) {
+      return undefined
+    }
+
+    const maxBytesForPreview = 1024
+    const truncated = bodyBytes.length > maxBytesForPreview
+    const slice = truncated ? bodyBytes.slice(0, maxBytesForPreview) : bodyBytes
+    const isText = this.isTextualContent(contentType, slice)
+
+    let preview: string
+    if (isText) {
+      try {
+        preview = Utils.toUTF8(slice)
+      } catch {
+        preview = this.formatBinaryPreview(slice, truncated)
+      }
+    } else {
+      preview = this.formatBinaryPreview(slice, truncated)
+    }
+
+    if (preview.length > 512) {
+      preview = `${preview.slice(0, 512)}…`
+    }
+    if (truncated) {
+      preview = `${preview} (truncated)`
+    }
+    return preview
+  }
+
+  private isTextualContent (contentType: string | null, sample: number[]): boolean {
+    if (sample.length === 0) {
+      return false
+    }
+
+    if (contentType != null) {
+      const lowered = contentType.toLowerCase()
+      const textualTokens = [
+        'application/json',
+        'application/problem+json',
+        'application/xml',
+        'application/xhtml+xml',
+        'application/javascript',
+        'application/ecmascript',
+        'application/x-www-form-urlencoded',
+        'text/'
+      ]
+      if (textualTokens.some(token => lowered.includes(token)) || lowered.includes('charset=')) {
+        return true
+      }
+    }
+
+    const printableCount = sample.reduce((count, byte) => {
+      if (byte === 9 || byte === 10 || byte === 13) {
+        return count + 1
+      }
+      if (byte >= 32 && byte <= 126) {
+        return count + 1
+      }
+      return count
+    }, 0)
+    return (printableCount / sample.length) > 0.8
+  }
+
+  private formatBinaryPreview (bytes: number[], truncated: boolean): string {
+    const hex = bytes.map(byte => byte.toString(16).padStart(2, '0')).join('')
+    return `0x${hex}${truncated ? '…' : ''}`
+  }
+
+  /**
+   * Deserializes a request payload from a byte array into an HTTP request-like structure.
+   *
+   * @param payload - The serialized payload to deserialize.
+   * @returns An object representing the deserialized request, including the method,
+   *          URL postfix (path and query string), headers, body, and request ID.
+   */
+  deserializeRequestPayload (payload: number[]): {
+    method: string
+    urlPostfix: string
+    headers: Record<string, string>
+    body: number[]
+    requestId: string
+  } {
+    // Create a reader
+    const requestReader = new Utils.Reader(payload)
+    // The first 32 bytes is the requestId
+    const requestId = Utils.toBase64(requestReader.read(32))
+
+    // Method
+    const methodLength = requestReader.readVarIntNum()
+    let method = 'GET'
+    if (methodLength > 0) {
+      method = Utils.toUTF8(requestReader.read(methodLength))
+    }
+
+    // Path
+    const pathLength = requestReader.readVarIntNum()
+    let path = ''
+    if (pathLength > 0) {
+      path = Utils.toUTF8(requestReader.read(pathLength))
+    }
+
+    // Search
+    const searchLength = requestReader.readVarIntNum()
+    let search = ''
+    if (searchLength > 0) {
+      search = Utils.toUTF8(requestReader.read(searchLength))
+    }
+
+    // Read headers
+    const requestHeaders = {}
+    const nHeaders = requestReader.readVarIntNum()
+    if (nHeaders > 0) {
+      for (let i = 0; i < nHeaders; i++) {
+        const nHeaderKeyBytes = requestReader.readVarIntNum()
+        const headerKeyBytes = requestReader.read(nHeaderKeyBytes)
+        const headerKey = Utils.toUTF8(headerKeyBytes)
+        const nHeaderValueBytes = requestReader.readVarIntNum()
+        const headerValueBytes = requestReader.read(nHeaderValueBytes)
+        const headerValue = Utils.toUTF8(headerValueBytes)
+        requestHeaders[headerKey] = headerValue
+      }
+    }
+
+    // Read body
+    let requestBody
+    const requestBodyBytes = requestReader.readVarIntNum()
+    if (requestBodyBytes > 0) {
+      requestBody = requestReader.read(requestBodyBytes)
+    }
+
+    // Return the deserialized RequestInit
+    return {
+      urlPostfix: path + search,
+      method,
+      headers: requestHeaders,
+      body: requestBody,
+      requestId
+    }
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/auth/transports/__tests__/SimplifiedFetchTransport.test.ts

@@ -0,0 +1,126 @@
+import { jest } from '@jest/globals'
+import { SimplifiedFetchTransport } from '../SimplifiedFetchTransport.js'
+import * as Utils from '../../../primitives/utils.js'
+import { AuthMessage } from '../../types.js'
+
+function createGeneralPayload (path = '/resource', method = 'GET'): number[] {
+  const writer = new Utils.Writer()
+  const requestId = new Array(32).fill(1)
+  writer.write(requestId)
+
+  const methodBytes = Utils.toArray(method, 'utf8')
+  writer.writeVarIntNum(methodBytes.length)
+  writer.write(methodBytes)
+
+  const pathBytes = Utils.toArray(path, 'utf8')
+  writer.writeVarIntNum(pathBytes.length)
+  writer.write(pathBytes)
+
+  writer.writeVarIntNum(-1) // no query string
+  writer.writeVarIntNum(0) // no headers
+  writer.writeVarIntNum(-1) // no body
+
+  return writer.toArray()
+}
+
+function createGeneralMessage (overrides: Partial<AuthMessage> = {}): AuthMessage {
+  return {
+    version: '1.0',
+    messageType: 'general',
+    identityKey: 'client-key',
+    nonce: 'client-nonce',
+    yourNonce: 'server-nonce',
+    payload: createGeneralPayload(),
+    signature: new Array(64).fill(0),
+    ...overrides
+  }
+}
+
+afterEach(() => {
+  jest.restoreAllMocks()
+})
+
+describe('SimplifiedFetchTransport send', () => {
+  test('wraps network failures with context', async () => {
+    const fetchMock: jest.MockedFunction<typeof fetch> = jest.fn()
+    fetchMock.mockRejectedValue(new Error('network down'))
+    const transport = new SimplifiedFetchTransport('https://api.example.com', fetchMock as any)
+    await transport.onData(async () => {})
+    const message = createGeneralMessage()
+
+    let caught: any
+    await expect((async () => {
+      try {
+        await transport.send(message)
+      } catch (error) {
+        caught = error
+        throw error
+      }
+    })()).rejects.toThrow('Network error while sending authenticated request to https://api.example.com/resource: network down')
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    expect(fetchMock.mock.calls[0][0]).toBe('https://api.example.com/resource')
+    expect(caught).toBeInstanceOf(Error)
+    expect(caught.cause).toBeInstanceOf(Error)
+    expect(caught.cause?.message).toBe('network down')
+  })
+
+  test('throws when server omits authentication headers', async () => {
+    const response = new Response('missing auth', {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/plain'
+      }
+    })
+    const fetchMock: jest.MockedFunction<typeof fetch> = jest.fn()
+    fetchMock.mockResolvedValue(response)
+    const transport = new SimplifiedFetchTransport('https://api.example.com', fetchMock as any)
+    await transport.onData(async () => {})
+
+    const message = createGeneralMessage()
+
+    let thrown: any
+    await expect((async () => {
+      try {
+        await transport.send(message)
+      } catch (error) {
+        thrown = error
+        throw error
+      }
+    })()).rejects.toThrow('Received HTTP 200 from https://api.example.com/resource without valid BSV authentication (missing headers: x-bsv-auth-version, x-bsv-auth-identity-key, x-bsv-auth-signature)')
+
+    expect(thrown.details).toMatchObject({
+      url: 'https://api.example.com/resource',
+      status: 200,
+      missingHeaders: [
+        'x-bsv-auth-version',
+        'x-bsv-auth-identity-key',
+        'x-bsv-auth-signature'
+      ]
+    })
+    expect(thrown.details.bodyPreview).toContain('missing auth')
+  })
+
+  test('rejects malformed requested certificates header', async () => {
+    const fetchMock: jest.MockedFunction<typeof fetch> = jest.fn()
+    fetchMock.mockResolvedValue(new Response('', {
+      status: 200,
+      headers: {
+        'x-bsv-auth-version': '0.1',
+        'x-bsv-auth-identity-key': 'server-key',
+        'x-bsv-auth-signature': 'deadbeef',
+        'x-bsv-auth-message-type': 'general',
+        'x-bsv-auth-request-id': Utils.toBase64(new Array(32).fill(2)),
+        'x-bsv-auth-requested-certificates': 'not-json'
+      }
+    }))
+
+    const transport = new SimplifiedFetchTransport('https://api.example.com', fetchMock as any)
+    await transport.onData(async () => {})
+    const message = createGeneralMessage()
+
+    await expect(transport.send(message)).rejects.toThrow(
+      'Failed to parse x-bsv-auth-requested-certificates returned by https://api.example.com/resource: not-json'
+    )
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/auth/transports/index.ts

@@ -0,0 +1 @@
+export * from './SimplifiedFetchTransport.js'

package/mobile/node_modules/@bsv/sdk/src/auth/types.ts

@@ -0,0 +1,42 @@
+import { VerifiableCertificate } from './certificates/VerifiableCertificate.js'
+
+export interface RequestedCertificateTypeIDAndFieldList {
+  [certificateTypeID: string]: string[]
+}
+
+// Define the structure for the requested certificates set
+export interface RequestedCertificateSet {
+  certifiers: string[]
+  types: RequestedCertificateTypeIDAndFieldList
+}
+
+export interface AuthMessage {
+  version: string
+  messageType:
+  | 'initialRequest'
+  | 'initialResponse'
+  | 'certificateRequest'
+  | 'certificateResponse'
+  | 'general'
+  identityKey: string // Sender's public key (used for identity verification)
+  nonce?: string // Sender's nonce (256-bit random value)
+  initialNonce?: string
+  yourNonce?: string // The recipient's nonce from a previous message (if applicable)
+  certificates?: VerifiableCertificate[] // Optional: List of certificates (if required/requested)
+  requestedCertificates?: RequestedCertificateSet // Optional: List of requested certificates
+  payload?: number[] // The actual message data (optional, could be a string or an object)
+  signature?: number[] // Digital signature covering the entire message
+}
+
+export interface Transport {
+  send: (message: AuthMessage) => Promise<void>
+  onData: (callback: (message: AuthMessage) => Promise<void>) => Promise<void>
+}
+
+export interface PeerSession {
+  isAuthenticated: boolean
+  sessionNonce?: string
+  peerNonce?: string
+  peerIdentityKey?: string
+  lastUpdate: number
+}