@bsv/sdk 1.3.35 → 1.4.0

package/src/auth/__tests/Peer.test.ts

@@ -6,7 +6,7 @@ import { Utils, PrivateKey } from '../../primitives/index.js'
 import { VerifiableCertificate } from '../../auth/certificates/VerifiableCertificate.js'
 import { MasterCertificate } from '../../auth/certificates/MasterCertificate.js'
 import { getVerifiableCertificates } from '../../auth/utils/getVerifiableCertificates.js'
-import { CompletedProtoWallet } from '../../../mod.js'
+import { CompletedProtoWallet } from '../certificates/__tests/CompletedProtoWallet.js'
 
 jest.mock('../../auth/utils/getVerifiableCertificates')
 
@@ -211,15 +211,13 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob received message:', Utils.toUTF8(payload))
           await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
           resolve()
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
       alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Alice received message:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -260,29 +258,26 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob 1 received message:', Utils.toUTF8(payload))
           await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
           resolve()
           bobMessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     let aliceReceivedGeneralMessageOnFirstDevice = new Promise<void>((resolve) => {
       aliceFirstDevice.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Alice 1 received message:', Utils.toUTF8(payload))
           resolve()
           alice1MessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     const aliceReceivedGeneralMessageOnOtherDevice = new Promise<void>((resolve) => {
       aliceOtherDevice.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Alice 2 received message:', Utils.toUTF8(payload))
           resolve()
           alice2MessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
@@ -333,16 +328,16 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Use a for...of loop instead of forEach with an async callback.
             for (const cert of certificatesReceivedByBob) {
               // Decrypt to ensure it has the correct fields.
-              const decryptedFields = await cert.decryptFields(walletB)
+              // const decryptedFields = await cert.decryptFields(walletB)
               if (cert.certifier !== 'bob') {
-                console.log('Bob accepted the message:', Utils.toUTF8(payload))
-                console.log('Decrypted fields:', decryptedFields)
+                // console.log('Bob accepted the message:', Utils.toUTF8(payload))
+                // console.log('Decrypted fields:', decryptedFields)
               }
             }
           }
           resolve()
         })().catch((e) => {
-          console.error(e)
+          // console.error(e)
         })
       })
     })
@@ -401,9 +396,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             Object.keys(decryptedFields).length !== 0 &&
             typeof decryptedFields.libraryCardNumber !== 'undefined'
           ) {
-            console.log(
-              `Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`
-            )
+            // console.log(
+            //   `Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`
+            // )
             aliceAcceptedLibraryCard()
           }
         }
@@ -412,7 +407,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -457,7 +452,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
           await bobReceivedCertificates
-          console.log('Bob received message:', Utils.toUTF8(payload))
+          // console.log('Bob received message:', Utils.toUTF8(payload))
 
           // Bob requests additional certificates after initial communication
           await bob.requestCertificates(certificatesToRequest, senderPublicKey)
@@ -478,11 +473,11 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Decrypt to confirm
             for (const cert of certificates) {
               const decrypted = await cert.decryptFields(walletB)
-              console.log(
-                'Bob received additional certificates from Alice:',
-                cert
-              )
-              console.log('Decrypted fields:', decrypted)
+              // console.log(
+              //   'Bob received additional certificates from Alice:',
+              //   cert
+              // )
+              // console.log('Decrypted fields:', decrypted)
             }
             resolve()
           }
@@ -540,9 +535,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Decrypt Alice's certificate fields
             const decryptedFields = await cert.decryptFields(walletB)
             if (typeof decryptedFields.membershipStatus !== 'undefined') {
-              console.log(
-                `Bob received Alice's membership status: ${decryptedFields.membershipStatus}`
-              )
+              // console.log(
+              //   `Bob received Alice's membership status: ${decryptedFields.membershipStatus}`
+              // )
               bobAcceptedMembershipStatus()
               resolve()
             }
@@ -556,7 +551,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -633,14 +628,14 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletA)
             if (decryptedFields.driversLicenseNumber !== undefined) {
-              console.log(
-                `Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`
-              )
+              // console.log(
+              //   `Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              // )
               aliceAcceptedBobDL()
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       }
       )
     })
@@ -651,14 +646,14 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletB)
             if (decryptedFields.driversLicenseNumber !== undefined) {
-              console.log(
-                `Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`
-              )
+              // console.log(
+              //   `Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              // )
               bobAcceptedAliceDL()
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       }
       )
     })
@@ -666,19 +661,19 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+          // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
           await bob.toPeer(
             Utils.toArray('Looking forward to carpooling!'),
             senderPublicKey
           )
           resolve()
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
     const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
       alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Alice received message from Bob:', Utils.toUTF8(payload))
+        // console.log('Alice received message from Bob:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -759,14 +754,14 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletA)
             if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
-              console.log(
-                `Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
-              )
+              // console.log(
+              //   `Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              // )
               aliceAcceptedPartialCert()
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
@@ -776,20 +771,20 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletB)
             if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
-              console.log(
-                `Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
-              )
+              // console.log(
+              //   `Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              // )
               bobAcceptedPartialCert()
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message:', Utils.toUTF8(payload))
+        // console.log('Bob received message:', Utils.toUTF8(payload))
         resolve()
       })
     })

package/src/auth/certificates/Certificate.ts

@@ -1,14 +1,14 @@
 import {
-  Utils,
   Base64String,
   PubKeyHex,
   HexString,
   OutpointString,
   CertificateFieldNameUnder50Bytes,
-  Signature,
-  WalletProtocol,
-  ProtoWallet
-} from '../../../mod.js'
+  WalletProtocol
+} from '../../wallet/Wallet.interfaces.js'
+import * as Utils from '../../primitives/utils.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
+import Signature from '../../primitives/Signature.js'
 
 /**
  * Represents an Identity Certificate as per the Wallet interface specifications.

package/src/auth/certificates/MasterCertificate.ts

@@ -1,16 +1,16 @@
 import {
-  SymmetricKey,
-  Utils,
   Base64String,
   CertificateFieldNameUnder50Bytes,
   HexString,
   OutpointString,
   PubKeyHex,
-  Random,
   WalletCounterparty,
-  ProtoWallet
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
 import Certificate from './Certificate.js'
+import * as Utils from '../../primitives/utils.js'
+import SymmetricKey from '../../primitives/SymmetricKey.js'
+import Random from '../../primitives/Random.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
 
 interface CreateCertificateFieldsResult {
   certificateFields: Record<CertificateFieldNameUnder50Bytes, Base64String>

package/src/auth/certificates/VerifiableCertificate.ts

@@ -1,13 +1,13 @@
-import {
-  SymmetricKey,
-  Utils,
+import type {
+  PubKeyHex,
   Base64String,
   CertificateFieldNameUnder50Bytes,
   HexString,
   OutpointString,
-  PubKeyHex,
-  ProtoWallet
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
+import SymmetricKey from '../../primitives/SymmetricKey.js'
+import * as Utils from '../../primitives/utils.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
 import Certificate from './Certificate.js'
 
 /**

package/src/auth/certificates/__tests/CompletedProtoWallet.ts

@@ -1,35 +1,21 @@
 //@ts-nocheck
-import { PrivateKey } from '../../../../mod.js'
+import PrivateKey from '../../../primitives/PrivateKey.js'
 import {
   ProtoWallet,
   WalletInterface,
-
   CreateActionResult,
-
   SignActionResult,
-
   AbortActionResult,
-
   ListActionsResult,
-
   InternalizeActionResult,
-
   ListOutputsResult,
-
   RelinquishOutputResult,
-
   AcquireCertificateResult,
-
   ListCertificatesResult,
-
   ProveCertificateResult,
-
   RelinquishCertificateResult,
-
   DiscoverCertificatesResult,
-
   GetHeightResult,
-
   GetHeaderResult,
   KeyDeriverApi,
   KeyDeriver,

package/src/auth/clients/AuthFetch.ts

@@ -1,19 +1,31 @@
 // @ts-nocheck
-import { Utils, Random, P2PKH, PublicKey, WalletInterface, createNonce } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
+import Random from '../../primitives/Random.js'
+import P2PKH from '../../script/templates/P2PKH.js'
+import PublicKey from '../../primitives/PublicKey.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { createNonce } from '../utils/createNonce.js'
 import { Peer } from '../Peer.js'
 import { SimplifiedFetchTransport } from '../transports/SimplifiedFetchTransport.js'
 import { SessionManager } from '../SessionManager.js'
 import { RequestedCertificateSet } from '../types.js'
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 import { Writer } from '../../primitives/utils.js'
+import { getVerifiableCertificates } from '../utils/index.js'
 
-type SimplifiedFetchRequestOptions = {
-  method?: string,
-  headers?: Record<string, string>,
-  body?: any,
+interface SimplifiedFetchRequestOptions {
+  method?: string
+  headers?: Record<string, string>
+  body?: any
   retryCounter?: number
 }
-type AuthPeer = { peer: Peer, identityKey?: string, supportsMutualAuth?: boolean }
+
+interface AuthPeer {
+  peer: Peer
+  identityKey?: string
+  supportsMutualAuth?: boolean
+  pendingCertificateRequests: Array<true>
+}
 
 const PAYMENT_VERSION = '1.0'
 
@@ -26,11 +38,11 @@ const PAYMENT_VERSION = '1.0'
  * and sending BSV payment transactions when necessary.
  */
 export class AuthFetch {
-  private sessionManager: SessionManager
-  private wallet: WalletInterface
+  private readonly sessionManager: SessionManager
+  private readonly wallet: WalletInterface
   private callbacks: Record<string, { resolve: Function, reject: Function }> = {}
-  private certificatesReceived: VerifiableCertificate[] = []
-  private requestedCertificates?: RequestedCertificateSet
+  private readonly certificatesReceived: VerifiableCertificate[] = []
+  private readonly requestedCertificates?: RequestedCertificateSet
   peers: Record<string, AuthPeer> = {}
 
   /**
@@ -58,7 +70,7 @@ export class AuthFetch {
    * @throws Will throw an error if unsupported headers are used or other validation fails.
    */
   async fetch(url: string, config: SimplifiedFetchRequestOptions = {}): Promise<Response> {
-    if (config.retryCounter) {
+    if (typeof config.retryCounter === 'number') {
       if (config.retryCounter <= 0) {
         throw new Error('Request failed after maximum number of retries.')
       }
@@ -79,13 +91,28 @@ export class AuthFetch {
           // Create a peer for the request
           const newTransport = new SimplifiedFetchTransport(baseURL)
           peerToUse = {
-            peer: new Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager)
+            peer: new Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager),
+            pendingCertificateRequests: []
           }
           this.peers[baseURL] = peerToUse
-          const callbackId = this.peers[baseURL].peer.listenForCertificatesReceived((senderPublicKey: string, certs: VerifiableCertificate[]) => {
+          this.peers[baseURL].peer.listenForCertificatesReceived((senderPublicKey: string, certs: VerifiableCertificate[]) => {
             this.certificatesReceived.push(...certs)
-            // peerToUse.peer.stopListeningForCertificatesReceived()
           })
+          this.peers[baseURL].peer.listenForCertificatesRequested((async (verifier: string, requestedCertificates: RequestedCertificateSet) => {
+            try {
+              this.peers[baseURL].pendingCertificateRequests.push(true)
+              const certificatesToInclude = await getVerifiableCertificates(
+                this.wallet,
+                requestedCertificates,
+                verifier
+              )
+              await this.peers[baseURL].peer.sendCertificateResponse(verifier, certificatesToInclude)
+            } finally {
+              // Give the backend 500 ms to process the certificates we just sent, before releasing the queue entry
+              await new Promise(resolve => setTimeout(resolve, 500))
+              this.peers[baseURL].pendingCertificateRequests.shift()
+            }
+          }) as Function)
         } else {
           // Check if there's a session associated with this baseURL
           if (this.peers[baseURL].supportsMutualAuth === false) {
@@ -174,6 +201,20 @@ export class AuthFetch {
           delete this.callbacks[requestNonceAsBase64]
         })
 
+        // Before sending general messages to the peer, ensure that no certificate requests are pending.
+        // This way, the user would need to choose to either allow or reject the certificate request first.
+        // If the server has a resource that requires certificates to be sent before access would be granted,
+        // this makes sure the user has a chance to send the certificates before the resource is requested.
+        if (peerToUse.pendingCertificateRequests.length > 0) {
+          await new Promise(resolve => {
+            setInterval(() => {
+              if (peerToUse.pendingCertificateRequests.length === 0) {
+                resolve()
+              }
+            }, 100) // Check every 100 ms for the user to finish responding
+          })
+        }
+
         // Send the request, now that all listeners are set up
         await peerToUse.peer.toPeer(writer.toArray(), peerToUse.identityKey).catch(async error => {
           if (error.message.includes('Session not found for nonce')) {
@@ -217,7 +258,7 @@ export class AuthFetch {
     const baseURL = parsedUrl.origin
 
     let peerToUse: { peer: Peer; identityKey?: string }
-    if (this.peers[baseURL]) {
+    if (typeof this.peers[baseURL] !== 'undefined') {
       peerToUse = { peer: this.peers[baseURL].peer }
     } else {
       const newTransport = new SimplifiedFetchTransport(baseURL)
@@ -233,7 +274,7 @@ export class AuthFetch {
     }
 
     // Return a promise that resolves when certificates are received
-    return new Promise<VerifiableCertificate[]>(async (resolve, reject) => {
+    return await new Promise<VerifiableCertificate[]>((async (resolve, reject) => {
       // Set up the listener before making the request
       const callbackId = peerToUse.peer.listenForCertificatesReceived((_senderPublicKey: string, certs: VerifiableCertificate[]) => {
         peerToUse.peer.stopListeningForCertificatesReceived(callbackId)
@@ -248,7 +289,7 @@ export class AuthFetch {
         peerToUse.peer.stopListeningForCertificatesReceived(callbackId)
         reject(err)
       }
-    })
+    }) as Function)
   }
 
   /**
@@ -513,4 +554,4 @@ export class AuthFetch {
     // 9. Fallback
     throw new Error('Unsupported body type in this SimplifiedFetch implementation.')
   }
-}
+}

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 // @ts-ignore
 import { AuthMessage, RequestedCertificateSet, Transport } from "../types.js"
-import { Utils } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
 
 const SUCCESS_STATUS_CODES = [200, 402]
 
@@ -42,25 +42,38 @@ export class SimplifiedFetchTransport implements Transport {
     if (!this.onDataCallback) {
       throw new Error('Listen before you start speaking. God gave you two ears and one mouth for a reason.')
     }
-
     if (message.messageType !== 'general') {
-      const response = await this.fetchClient(`${this.baseUrl}/.well-known/auth`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(message)
-      })
-      // Handle the response if data is received and callback is set
-      if (response.ok && this.onDataCallback) {
-        const responseMessage = await response.json()
-        if (responseMessage?.status !== 'certificate received') {
-          this.onDataCallback(responseMessage as AuthMessage)
+      return new Promise(async (resolve, reject) => {
+        try {
+          const responsePromise = this.fetchClient(`${this.baseUrl}/.well-known/auth`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(message)
+          })
+
+          if (message.messageType !== "initialRequest") {
+            resolve()
+          }
+          const response = await responsePromise
+
+          // Handle the response if data is received and callback is set
+          if (response.ok && this.onDataCallback) {
+            const responseMessage = await response.json()
+            this.onDataCallback(responseMessage as AuthMessage)
+          } else {
+            // Server may be a non authenticated server
+            throw new Error('HTTP server failed to authenticate')
+          }
+          if (message.messageType === "initialRequest") {
+            resolve()
+          }
+        } catch (e) {
+          reject(e)
+          return
         }
-      } else {
-        // Server may be a non authenticated server
-        throw new Error('HTTP server failed to authenticate')
-      }
+      })
     } else {
       // Parse message payload
       const httpRequest = this.deserializeRequestPayload(message.payload)
@@ -105,7 +118,6 @@ export class SimplifiedFetchTransport implements Transport {
         }
       }
 
-
       // Send the actual fetch request to the server
       const response = await this.fetchClient(url, {
         method: httpRequestWithAuthHeaders.method,

package/src/auth/utils/__tests/cryptononce.test.ts

@@ -141,8 +141,6 @@ describe('verifyNonce', () => {
       counterparty: (await serverWallet.getPublicKey({ identityKey: true }))
         .publicKey
     })
-
-    console.log(Utils.toBase64(serialNumber))
     expect(valid).toEqual(true)
   })
 })

package/src/auth/utils/createNonce.ts

@@ -1,10 +1,10 @@
 import {
-  Utils,
-  Random,
   WalletInterface,
   WalletCounterparty,
   Base64String
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
+import * as Utils from '../../primitives/utils.js'
+import Random from '../../primitives/Random.js'
 
 /**
  * Creates a nonce derived from a wallet

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,5 +1,5 @@
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
-import { WalletInterface } from '../../../mod.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
 import { RequestedCertificateSet } from '../types.js'
 
 /**

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,5 @@
-import { Utils, WalletInterface, WalletCounterparty, Base64String } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
+import { WalletInterface, WalletCounterparty, Base64String } from '../../wallet/Wallet.interfaces.js'
 
 /**
  * Verifies a nonce derived from a wallet

package/src/overlay-tools/LookupResolver.ts

@@ -227,8 +227,8 @@ export default class LookupResolver {
             continue
           }
         }
-      } catch (error) {
-        console.error('Error processing response outputs:', error)
+      } catch (_) {
+        // Error processing output, proceed.
       }
     }
     return {

package/src/primitives/utils.ts

@@ -359,7 +359,7 @@ export const fromBase58Check = (
   str: string,
   enc?: 'hex',
   prefixLength: number = 1
-): any => {
+): { data: number[] | string, prefix: number[] | string } => {
   const bin = fromBase58(str)
   let prefix: string | number[] = bin.slice(0, prefixLength)
   let data: string | number[] = bin.slice(prefixLength, -4)