@bsv/sdk 1.3.12 → 1.3.14

package/src/wallet/ProtoWallet.ts

@@ -1,15 +1,20 @@
 import { KeyDeriver, KeyDeriverApi } from './KeyDeriver.js'
-import { Hash, ECDSA, BigNumber, Signature, Schnorr, PublicKey, Point, PrivateKey } from '../primitives/index.js'
 import {
-  AuthenticatedResult,
+  Hash,
+  ECDSA,
+  BigNumber,
+  Signature,
+  Schnorr,
+  PublicKey,
+  Point,
+  PrivateKey
+} from '../primitives/index.js'
+import {
   CreateHmacArgs,
   CreateHmacResult,
   CreateSignatureArgs,
   CreateSignatureResult,
-  GetNetworkResult,
   GetPublicKeyArgs,
-  GetVersionResult,
-  OriginatorDomainNameStringUnder250Bytes,
   PubKeyHex,
   RevealCounterpartyKeyLinkageArgs,
   RevealCounterpartyKeyLinkageResult,
@@ -37,27 +42,38 @@ export class ProtoWallet {
 
   constructor (rootKeyOrKeyDeriver?: PrivateKey | 'anyone' | KeyDeriverApi) {
     if (typeof (rootKeyOrKeyDeriver as KeyDeriver).identityKey !== 'string') {
-      rootKeyOrKeyDeriver = new KeyDeriver(rootKeyOrKeyDeriver as PrivateKey | 'anyone')
+      rootKeyOrKeyDeriver = new KeyDeriver(
+        rootKeyOrKeyDeriver as PrivateKey | 'anyone'
+      )
     }
     this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
 
   async getPublicKey (
-    args: GetPublicKeyArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: GetPublicKeyArgs
   ): Promise<{ publicKey: PubKeyHex }> {
     if (args.identityKey) {
+      if (this.keyDeriver == null) {
+        throw new Error('keyDeriver is undefined')
+      }
       return { publicKey: this.keyDeriver.rootKey.toPublicKey().toString() }
     } else {
-      if (!args.protocolID || !args.keyID) {
-        throw new Error('protocolID and keyID are required if identityKey is false or undefined.')
+      if (args.protocolID == null || args.keyID == null || args.keyID === '') {
+        throw new Error(
+          'protocolID and keyID are required if identityKey is false or undefined.'
+        )
       }
+      const keyDeriver =
+        this.keyDeriver ??
+        (() => {
+          throw new Error('keyDeriver is undefined')
+        })()
       return {
-        publicKey: this.keyDeriver
+        publicKey: keyDeriver
           .derivePublicKey(
             args.protocolID,
             args.keyID,
-            args.counterparty || 'self',
+            args.counterparty ?? 'self',
             args.forSelf
           )
           .toString()
@@ -66,12 +82,21 @@ export class ProtoWallet {
   }
 
   async revealCounterpartyKeyLinkage (
-    args: RevealCounterpartyKeyLinkageArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: RevealCounterpartyKeyLinkageArgs
   ): Promise<RevealCounterpartyKeyLinkageResult> {
-    const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
+    const { publicKey: identityKey } = await this.getPublicKey({
+      identityKey: true
+    })
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const linkage = this.keyDeriver.revealCounterpartySecret(args.counterparty)
-    const linkageProof = new Schnorr().generateProof(this.keyDeriver.rootKey, this.keyDeriver.rootKey.toPublicKey(), PublicKey.fromString(args.counterparty), Point.fromDER(linkage))
+    const linkageProof = new Schnorr().generateProof(
+      this.keyDeriver.rootKey,
+      this.keyDeriver.rootKey.toPublicKey(),
+      PublicKey.fromString(args.counterparty),
+      Point.fromDER(linkage)
+    )
     const linkageProofBin = [
       ...linkageProof.R.encode(true),
       ...linkageProof.SPrime.encode(true),
@@ -101,10 +126,14 @@ export class ProtoWallet {
   }
 
   async revealSpecificKeyLinkage (
-    args: RevealSpecificKeyLinkageArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: RevealSpecificKeyLinkageArgs
   ): Promise<RevealSpecificKeyLinkageResult> {
-    const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
+    const { publicKey: identityKey } = await this.getPublicKey({
+      identityKey: true
+    })
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const linkage = this.keyDeriver.revealSpecificSecret(
       args.counterparty,
       args.protocolID,
@@ -112,13 +141,19 @@ export class ProtoWallet {
     )
     const { ciphertext: encryptedLinkage } = await this.encrypt({
       plaintext: linkage,
-      protocolID: [2, `specific linkage revelation ${args.protocolID[0]} ${args.protocolID[1]}`],
+      protocolID: [
+        2,
+        `specific linkage revelation ${args.protocolID[0]} ${args.protocolID[1]}`
+      ],
       keyID: args.keyID,
       counterparty: args.verifier
     })
     const { ciphertext: encryptedLinkageProof } = await this.encrypt({
       plaintext: [0], // Proof type 0, no proof provided
-      protocolID: [2, `specific linkage revelation ${args.protocolID[0]} ${args.protocolID[1]}`],
+      protocolID: [
+        2,
+        `specific linkage revelation ${args.protocolID[0]} ${args.protocolID[1]}`
+      ],
       keyID: args.keyID,
       counterparty: args.verifier
     })
@@ -135,95 +170,129 @@ export class ProtoWallet {
   }
 
   async encrypt (
-    args: WalletEncryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: WalletEncryptArgs
   ): Promise<WalletEncryptResult> {
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'self'
+      args.counterparty ?? 'self'
     )
     return { ciphertext: key.encrypt(args.plaintext) as number[] }
   }
 
   async decrypt (
-    args: WalletDecryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: WalletDecryptArgs
   ): Promise<WalletDecryptResult> {
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'self'
+      args.counterparty ?? 'self'
     )
     return { plaintext: key.decrypt(args.ciphertext) as number[] }
   }
 
   async createHmac (
-    args: CreateHmacArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: CreateHmacArgs
   ): Promise<CreateHmacResult> {
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'self'
+      args.counterparty ?? 'self'
     )
     return { hmac: Hash.sha256hmac(key.toArray(), args.data) }
   }
 
   async verifyHmac (
-    args: VerifyHmacArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: VerifyHmacArgs
   ): Promise<VerifyHmacResult> {
+    if (this.keyDeriver == null) {
+      throw new Error('keyDeriver is undefined')
+    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'self'
+      args.counterparty ?? 'self'
     )
-    const valid = Hash.sha256hmac(key.toArray(), args.data).toString() === args.hmac.toString()
+    const valid =
+      Hash.sha256hmac(key.toArray(), args.data).toString() ===
+      args.hmac.toString()
     if (!valid) {
-      const e = new Error('HMAC is not valid');
-      (e as any).code = 'ERR_INVALID_HMAC'
+      const e = new Error('HMAC is not valid') as Error & { code: string }
+      e.code = 'ERR_INVALID_HMAC'
       throw e
     }
     return { valid }
   }
 
   async createSignature (
-    args: CreateSignatureArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: CreateSignatureArgs
   ): Promise<CreateSignatureResult> {
-    if (!args.hashToDirectlySign && !args.data) {
+    if ((args.hashToDirectlySign == null) && (args.data == null)) {
       throw new Error('args.data or args.hashToDirectlySign must be valid')
     }
-    const hash: number[] = args.hashToDirectlySign || Hash.sha256(args.data)
-    const key = this.keyDeriver.derivePrivateKey(
+
+    const hash: number[] =
+      args.hashToDirectlySign ?? Hash.sha256(args.data ?? [])
+    const keyDeriver =
+      this.keyDeriver ??
+      (() => {
+        throw new Error('keyDeriver is undefined')
+      })()
+
+    const key = keyDeriver.derivePrivateKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'anyone'
+      args.counterparty ?? 'anyone'
     )
-    return { signature: ECDSA.sign(new BigNumber(hash), key, true).toDER() as number[] }
+
+    return {
+      signature: ECDSA.sign(new BigNumber(hash), key, true).toDER() as number[]
+    }
   }
 
   async verifySignature (
-    args: VerifySignatureArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: VerifySignatureArgs
   ): Promise<VerifySignatureResult> {
-    if (!args.hashToDirectlyVerify && !args.data) {
+    if ((args.hashToDirectlyVerify == null) && (args.data == null)) {
       throw new Error('args.data or args.hashToDirectlyVerify must be valid')
     }
-    const hash: number[] = args.hashToDirectlyVerify || Hash.sha256(args.data)
-    const key = this.keyDeriver.derivePublicKey(
+
+    const hash: number[] =
+      args.hashToDirectlyVerify ?? Hash.sha256(args.data ?? [])
+    const keyDeriver =
+      this.keyDeriver ??
+      (() => {
+        throw new Error('keyDeriver is undefined')
+      })()
+
+    const key = keyDeriver.derivePublicKey(
       args.protocolID,
       args.keyID,
-      args.counterparty || 'self',
+      args.counterparty ?? 'self',
       args.forSelf
     )
-    const valid = ECDSA.verify(new BigNumber(hash), Signature.fromDER(args.signature), key)
+
+    const valid = ECDSA.verify(
+      new BigNumber(hash),
+      Signature.fromDER(args.signature),
+      key
+    )
+
     if (!valid) {
-      const e = new Error('Signature is not valid');
-      (e as any).code = 'ERR_INVALID_SIGNATURE'
+      const e = new Error('Signature is not valid') as Error & { code: string }
+      e.code = 'ERR_INVALID_SIGNATURE'
       throw e
     }
+
     return { valid }
   }
 }