@bsv/sdk 1.7.6 → 1.8.0

package/src/wallet/WalletClient.ts

@@ -58,6 +58,7 @@ export default class WalletClient implements WalletInterface {
     | 'window.CWI'
     | 'json-api'
     | 'react-native'
+    | 'secure-json-api'
     | WalletInterface = 'auto',
     originator?: OriginatorDomainNameStringUnder250Bytes
   ) {
@@ -68,6 +69,7 @@ export default class WalletClient implements WalletInterface {
     if (substrate === 'XDM') substrate = new XDMSubstrate()
     if (substrate === 'json-api') substrate = new HTTPWalletJSON(originator)
     if (substrate === 'react-native') substrate = new ReactNativeWebView(originator)
+    if (substrate === 'secure-json-api') substrate = new HTTPWalletJSON(originator, 'https://localhost:2121')
     this.substrate = substrate
     this.originator = originator
   }
@@ -76,61 +78,58 @@ export default class WalletClient implements WalletInterface {
     if (typeof this.substrate === 'object') {
       return // substrate is already connected
     }
-    let sub: WalletInterface
-    const checkSub = async (timeout?: number): Promise<void> => {
-      let result
-      if (typeof timeout === 'number') {
-        result = await Promise.race([
-          sub.getVersion({}),
-          new Promise<never>((_resolve, reject) =>
-            setTimeout(() => reject(new Error('Timed out.')), timeout)
-          )
-        ])
-      } else {
-        result = await sub.getVersion({})
-      }
-      if (typeof result !== 'object' || typeof result.version !== 'string') {
-        throw new Error('Failed to use substrate.')
-      }
-    }
-    try {
-      sub = new WindowCWISubstrate()
-      await checkSub()
-      this.substrate = sub
-    } catch (e) {
-      // XDM failed, try the next one...
+
+    const attemptSubstrate = async (factory: () => WalletInterface, timeout?: number): Promise<{ success: boolean, sub?: WalletInterface }> => {
       try {
-        sub = new XDMSubstrate()
-        await checkSub(MAX_XDM_RESPONSE_WAIT)
-        this.substrate = sub
-      } catch (e) {
-        // HTTP wire failed, move on...
-        try {
-          sub = new WalletWireTransceiver(new HTTPWalletWire(this.originator))
-          await checkSub()
-          this.substrate = sub
-        } catch (e) {
-          // HTTP Wire failed, attempt the next...
-          try {
-            sub = new HTTPWalletJSON(this.originator)
-            await checkSub()
-            this.substrate = sub
-          } catch (e) {
-            // HTTP JSON failed, attempt the next...
-            try {
-              sub = new ReactNativeWebView(this.originator)
-              await checkSub()
-              this.substrate = sub
-            } catch (e) {
-              // No comms. Tell the user to install a BSV wallet.
-              throw new Error(
-                'No wallet available over any communication substrate. Install a BSV wallet today!'
-              )
-            }
-          }
+        const sub = factory()
+        let result
+        if (typeof timeout === 'number') {
+          result = await Promise.race([
+            sub.getVersion({}),
+            new Promise<never>((_resolve, reject) =>
+              setTimeout(() => reject(new Error('Timed out.')), timeout)
+            )
+          ])
+        } else {
+          result = await sub.getVersion({})
+        }
+        if (typeof result !== 'object' || typeof result.version !== 'string') {
+          return { success: false }
         }
+        return { success: true, sub }
+      } catch {
+        return { success: false }
       }
     }
+
+    // Try fast substrates first
+    const fastAttempts = [
+      attemptSubstrate(() => new WindowCWISubstrate()),
+      attemptSubstrate(() => new HTTPWalletJSON(this.originator, 'https://localhost:2121')),
+      attemptSubstrate(() => new HTTPWalletJSON(this.originator)),
+      attemptSubstrate(() => new ReactNativeWebView(this.originator)),
+      attemptSubstrate(() => new WalletWireTransceiver(new HTTPWalletWire(this.originator)))
+    ]
+
+    const fastResults = await Promise.allSettled(fastAttempts)
+    const fastSuccessful = fastResults
+      .filter((r): r is PromiseFulfilledResult<{ success: boolean, sub?: WalletInterface }> => r.status === 'fulfilled' && r.value.success && r.value.sub !== undefined)
+      .map(r => r.value.sub as WalletInterface)
+
+    if (fastSuccessful.length > 0) {
+      this.substrate = fastSuccessful[0]
+      return
+    }
+
+    // Fall back to slower XDM substrate
+    const xdmResult = await attemptSubstrate(() => new XDMSubstrate(), MAX_XDM_RESPONSE_WAIT)
+    if (xdmResult.success && xdmResult.sub !== undefined) {
+      this.substrate = xdmResult.sub
+    } else {
+      throw new Error(
+        'No wallet available over any communication substrate. Install a BSV wallet today!'
+      )
+    }
   }
 
   async createAction (args: CreateActionArgs): Promise<CreateActionResult> {

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -1782,6 +1782,27 @@ export default class WalletWireProcessor implements WalletWire {
             // Write certificate binary length and data
             resultWriter.writeVarIntNum(certBin.length)
             resultWriter.write(certBin)
+
+            if (cert.keyring && Object.keys(cert.keyring).length > 0) {
+              resultWriter.writeInt8(1) // Flag indicating keyring is present
+              const keyringEntries = Object.entries(cert.keyring)
+              resultWriter.writeVarIntNum(keyringEntries.length)
+              for (const [fieldName, fieldValue] of keyringEntries) {
+                const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
+                resultWriter.writeVarIntNum(fieldNameBytes.length)
+                resultWriter.write(fieldNameBytes)
+
+                const fieldValueBytes = Utils.toArray(fieldValue, 'base64')
+                resultWriter.writeVarIntNum(fieldValueBytes.length)
+                resultWriter.write(fieldValueBytes)
+              }
+            } else {
+              resultWriter.writeInt8(0) // Flag indicating no keyring
+            }
+
+            const verifierBytes = Utils.toArray(cert.verifier, 'hex')
+            resultWriter.writeVarIntNum(verifierBytes.length)
+            resultWriter.write(verifierBytes)
           }
 
           // Return the response

package/src/wallet/substrates/WalletWireTransceiver.ts

@@ -11,6 +11,7 @@ import {
   BooleanDefaultTrue,
   Byte,
   CertificateFieldNameUnder50Bytes,
+  CertificateResult,
   CreateActionArgs,
   CreateActionResult,
   DescriptionString5to50Bytes,
@@ -1672,22 +1673,33 @@ export default class WalletWireTransceiver implements WalletInterface {
     )
     const resultReader = new Utils.Reader(result)
     const totalCertificates = resultReader.readVarIntNum()
-    const certificates: Array<{
-      type: Base64String
-      subject: PubKeyHex
-      serialNumber: Base64String
-      certifier: PubKeyHex
-      revocationOutpoint: OutpointString
-      signature: HexString
-      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>
-    }> = []
+    const certificates: Array<CertificateResult> = []
     for (let i = 0; i < totalCertificates; i++) {
       const certificateLength = resultReader.readVarIntNum()
       const certificateBin = resultReader.read(certificateLength)
       const cert = Certificate.fromBinary(certificateBin)
+      const keyringForVerifier: Record<string, string> = {}
+      if (resultReader.readInt8() === 1) {
+        const numFields = resultReader.readVarIntNum()
+        for (let i = 0; i < numFields; i++) {
+          const fieldKeyLength = resultReader.readVarIntNum()
+          const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLength))
+          const fieldValueLength = resultReader.readVarIntNum()
+          keyringForVerifier[fieldKey] = Utils.toBase64(
+              resultReader.read(fieldValueLength)
+          )
+        }
+      }
+      const verifierLength = resultReader.readVarIntNum()
+      let verifier: string | undefined = undefined
+      if (verifierLength > 0) {
+        verifier = Utils.toUTF8(resultReader.read(verifierLength))
+      }
       certificates.push({
         ...cert,
-        signature: cert.signature as string
+        signature: cert.signature as string,
+        keyring: keyringForVerifier,
+        verifier,
       })
     }
     return {