@bsv/sdk 1.4.22 → 1.4.24

package/package.json

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

package/src/auth/certificates/VerifiableCertificate.ts

@@ -4,6 +4,7 @@ import type {
   CertificateFieldNameUnder50Bytes,
   HexString,
   OutpointString,
+  WalletCertificate,
 } from '../../wallet/Wallet.interfaces.js'
 import SymmetricKey from '../../primitives/SymmetricKey.js'
 import * as Utils from '../../primitives/utils.js'
@@ -50,6 +51,29 @@ export class VerifiableCertificate extends Certificate {
     this.decryptedFields = decryptedFields
   }
 
+  /**
+   *
+   * @param {WalletCertificate} certificate – The source certificate that was issued and signed by the certifier.
+   * @param {Record<CertificateFieldNameUnder50Bytes, string>} keyring – A allows the verifier to decrypt selected certificate fields.
+   * @returns {VerifiableCertificate} – A fully-formed instance containing the
+   *   original certificate data plus the supplied keyring.
+   */
+  static fromCertificate(
+    certificate: WalletCertificate,
+    keyring: Record<CertificateFieldNameUnder50Bytes, string>
+  ): VerifiableCertificate {
+    return new VerifiableCertificate(
+      certificate.type,
+      certificate.serialNumber,
+      certificate.subject,
+      certificate.certifier,
+      certificate.revocationOutpoint,
+      certificate.fields,
+      keyring,
+      certificate.signature
+    )
+  }
+
   /**
    * Decrypts selectively revealed certificate fields using the provided keyring and verifier wallet
    * @param {ProtoWallet} verifierWallet - The wallet instance of the certificate's verifier, used to decrypt field keys.

package/src/auth/certificates/__tests/VerifiableCertificate.test.ts

@@ -1,8 +1,9 @@
 import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
+import Certificate from '../../../auth/certificates/Certificate'
 import { PrivateKey, Utils } from '../../../../mod'
 import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
 import { MasterCertificate } from '../../../auth/certificates/MasterCertificate'
-import { ProtoWallet } from '../../../wallet/index'
+import { ProtoWallet, WalletCertificate } from '../../../wallet/index'
 
 describe('VerifiableCertificate', () => {
   const subjectPrivateKey = PrivateKey.fromRandom()
@@ -149,4 +150,30 @@ describe('VerifiableCertificate', () => {
       expect(decrypted).toEqual(plaintextFields)
     })
   })
+  
+  describe('fromCertificate', () => {
+    it('should create an equivalent VerifiableCertificate and decrypt correctly', async () => {
+      const baseCert = new Certificate(
+        verifiableCert.type,
+        verifiableCert.serialNumber,
+        verifiableCert.subject,
+        verifiableCert.certifier,
+        verifiableCert.revocationOutpoint,
+        verifiableCert.fields,
+        verifiableCert.signature        
+      ) as WalletCertificate
+
+      const verifiable = VerifiableCertificate.fromCertificate(
+        baseCert,
+        verifiableCert.keyring
+      )
+
+      expect(verifiable).toBeInstanceOf(VerifiableCertificate)
+      expect(verifiable.serialNumber).toEqual(sampleSerialNumber)
+      expect(verifiable.keyring).toEqual(verifiableCert.keyring)
+
+      const decrypted = await verifiable.decryptFields(verifierWallet)
+      expect(decrypted).toEqual(plaintextFields)
+    })
+  })
 })

package/src/auth/clients/AuthFetch.ts

@@ -495,6 +495,8 @@ export class AuthFetch {
       }
     })
 
+
+
     // Attach the payment to the request headers
     config.headers = config.headers || {}
     config.headers['x-bsv-payment'] = JSON.stringify({

package/src/transaction/broadcasters/Teranode.ts

@@ -0,0 +1,77 @@
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster
+} from '../Broadcaster.js'
+import Transaction from '../Transaction.js'
+import { binaryHttpClient, HttpClient } from '../http/index.js'
+
+/**
+ * Represents an Teranode transaction broadcaster.
+ */
+export default class Teranode implements Broadcaster {
+  readonly URL: string
+  readonly httpClient: HttpClient
+
+  /**
+   * Constructs an instance of the Teranode broadcaster.
+   *
+   * @param {string} URL - The URL endpoint for the Teranode API.
+   * @param {HttpClient} httpClient - The HTTP client used to make requests to the API, binaryHttpClient by default.
+   */
+  constructor(
+    URL: string,
+    httpClient: HttpClient = binaryHttpClient()
+  ) {
+    this.URL = URL
+    this.httpClient = httpClient
+  }
+
+  /**
+   * Broadcasts a transaction via Teranode.
+   *
+   * @param {Transaction} tx - The transaction to be broadcasted.
+   * @returns {Promise<BroadcastResponse | BroadcastFailure>} A promise that resolves to either a success or failure response.
+   */
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
+    const rawTx = tx.toEF()
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/octet-stream'
+      },
+      data: new Blob([new Uint8Array(rawTx)])
+    }
+    try {
+      const response = await this.httpClient.request<string>(
+        this.URL,
+        requestOptions
+      )
+      if (response.ok) {
+        const txid = tx.id('hex')
+        return {
+          status: 'success',
+          txid,
+          message: 'broadcast successful'
+        }
+      } else {
+        return {
+          status: 'error',
+          code: response.status.toString() ?? 'ERR_UNKNOWN',
+          description: response.data ?? 'Unknown error'
+        }
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        code: '500',
+        description:
+          typeof error.message === 'string'
+            ? error.message
+            : 'Internal Server Error'
+      }
+    }
+  }
+}

package/src/transaction/broadcasters/index.ts

@@ -1,4 +1,5 @@
 export { default as ARC } from './ARC.js'
 export type { ArcConfig } from './ARC.js'
 export { default as WhatsOnChainBroadcaster } from './WhatsOnChainBroadcaster.js'
+export { default as Teranode } from './Teranode.js'
 export { defaultBroadcaster } from './DefaultBroadcaster.js'

package/src/transaction/http/BinaryFetchClient.ts

@@ -0,0 +1,141 @@
+import {
+  HttpClient,
+  HttpClientRequestOptions,
+  HttpClientResponse
+} from './HttpClient.js'
+
+/** Node Https module interface limited to options needed by ts-sdk */
+export interface BinaryHttpsNodejs {
+  request: (
+    url: string,
+    options: HttpClientRequestOptions,
+    callback: (res: any) => void
+  ) => BinaryNodejsHttpClientRequest
+}
+
+/** Nodejs result of the Node https.request call limited to options needed by ts-sdk */
+export interface BinaryNodejsHttpClientRequest {
+  write: (chunk: Buffer) => void
+
+  on: (event: string, callback: (data: any) => void) => void
+
+  end: (() => void) & (() => void)
+}
+
+/**
+ * Adapter for Node Https module to be used as HttpClient
+ */
+export class BinaryNodejsHttpClient implements HttpClient {
+  constructor(private readonly https: BinaryHttpsNodejs) { }
+
+  async request(
+    url: string,
+    requestOptions: HttpClientRequestOptions
+  ): Promise<HttpClientResponse> {
+    return await new Promise((resolve, reject) => {
+      const req = this.https.request(url, requestOptions, (res) => {
+        let body = ''
+        res.on('data', (chunk: string) => {
+          body += chunk
+        })
+        res.on('end', () => {
+          const ok = res.statusCode >= 200 && res.statusCode <= 299
+          const mediaType = res.headers['content-type']
+          const data =
+            body !== '' && typeof mediaType === 'string' && mediaType.startsWith('application/json')
+              ? JSON.parse(body)
+              : body
+          resolve({
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            ok,
+            data
+          })
+        })
+      })
+
+      req.on('error', (error: Error) => {
+        reject(error)
+      })
+
+      if (requestOptions.data !== null && requestOptions.data !== undefined) {
+        req.write(Buffer.from(requestOptions.data))
+      }
+      req.end()
+    })
+  }
+}
+
+/** fetch function interface limited to options needed by ts-sdk */
+/**
+ * Makes a request to the server.
+ * @param url The URL to make the request to.
+ * @param options The request configuration.
+ */
+export type Fetch = (url: string, options: FetchOptions) => Promise<Response>
+
+/**
+ * An interface for configuration of the request to be passed to the fetch method
+ * limited to options needed by ts-sdk.
+ */
+export interface FetchOptions {
+  /** A string to set request's method. */
+  method?: string
+  /** An object literal set request's headers. */
+  headers?: Record<string, string>
+  /** An object or null to set request's body. */
+  body?: Buffer | Uint8Array | Blob | null
+}
+
+/**
+ * Adapter for Node Https module to be used as HttpClient
+ */
+export class BinaryFetchClient implements HttpClient {
+  constructor(private readonly fetch: Fetch) { }
+
+  async request<D>(
+    url: string,
+    options: HttpClientRequestOptions
+  ): Promise<HttpClientResponse<D>> {
+    const fetchOptions: FetchOptions = {
+      method: options.method,
+      headers: options.headers,
+      body: options.data
+    }
+
+    const res = await this.fetch(url, fetchOptions)
+    const data = await res.text()
+
+    return {
+      ok: res.ok,
+      status: res.status,
+      statusText: res.statusText,
+      data: data as D
+    }
+  }
+}
+
+export function binaryHttpClient(): HttpClient {
+  const noHttpClient: HttpClient = {
+    async request(..._): Promise<HttpClientResponse> {
+      throw new Error('No method available to perform HTTP request')
+    }
+  }
+
+  if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+    // Use fetch in a browser environment
+    return new BinaryFetchClient(window.fetch.bind(window))
+  } else if (typeof require !== 'undefined') {
+    // Use Node https module
+    // eslint-disable-next-line
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const https = require('https')
+      return new BinaryNodejsHttpClient(https)
+    } catch (e) {
+      return noHttpClient
+    }
+  } else {
+    return noHttpClient
+  }
+}

package/src/transaction/http/NodejsHttpClient.ts

@@ -54,7 +54,7 @@ export class NodejsHttpClient implements HttpClient {
         })
       })
 
-      req.on('error', (error) => {
+      req.on('error', (error: Error) => {
         reject(error)
       })
 

package/src/transaction/http/index.ts

@@ -4,6 +4,7 @@ export type {
   HttpClientRequestOptions
 } from './HttpClient.js'
 export { defaultHttpClient } from './DefaultHttpClient.js'
+export { binaryHttpClient } from './BinaryFetchClient.js'
 export { NodejsHttpClient } from './NodejsHttpClient.js'
 export { FetchHttpClient } from './FetchHttpClient.js'
 export type { Fetch, FetchOptions } from './FetchHttpClient.js'